Är postcovid en kultursjukdom?

<div class="kv-article-audio-player">  <div class="kv-aap-listen">    <div class="kv-listen-left">      <span>        <i class="fas fa-headphones-alt"></i>      </span>    </div>    <div class="kv-aap-listen-right">Lyssna på texten    </div>  </div><div id    = "kv-pod-holder-168687"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="168687" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="w4RyIHBvc3Rjb3ZpZCBlbiBrdWx0dXJzanVrZG9tPw==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci85LTA3LWFyLXBvc3Rjb3ZpZC1lbi1rdWx0dXJzanVrZG9tMi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvOS0wNy1hci1wb3N0Y292aWQtZW4ta3VsdHVyc2p1a2RvbTIubXAz">  <div class="kv-pod-holder-inner">    Laddar <span class="blink-me">...</span>  </div></div>  <div class="kv-listen-subscribe">    <span>Följ Kvartals poddar:</span>    <a target="_blank" href="https://podcasts.apple.com/se/podcast/kvartal/id1447122576?mt=2">Apple</a>    |     <a target="_blank" href="https://open.spotify.com/show/6NsieE1iFLypikr3slKII0?si=ppaUJpA3R-mo8L9L4XgudA">Spotify</a>  </div></div><div class="kvartal-meta clearfix" style="color: "><div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-postcovid-en-kultursjukdom%2F&amp;t=%C3%84r+postcovid+en+kultursjukdom%3F"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=%C3%84r+postcovid+en+kultursjukdom%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-postcovid-en-kultursjukdom%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-postcovid-en-kultursjukdom%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är postcovid en kultursjukdom?&body=https://kvartal.se/artiklar/ar-postcovid-en-kultursjukdom/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/168687/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div></div><div class="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2020/11/Erik-W-Larsson.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2020/11/Erik-W-Larsson.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/erik-w-larsson/">Erik W.&nbsp;Larsson</a> | 3 mars 2025<div class="author-desc">Erik W. Larsson är legitimerad läkare och specialist inom psykiatri, samt ST-läkare inom allmänmedicin.
</div>    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-postcovid-en-kultursjukdom%2F&amp;t=%C3%84r+postcovid+en+kultursjukdom%3F"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=%C3%84r+postcovid+en+kultursjukdom%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-postcovid-en-kultursjukdom%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-postcovid-en-kultursjukdom%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är postcovid en kultursjukdom?&body=https://kvartal.se/artiklar/ar-postcovid-en-kultursjukdom/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/168687/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/ar-postcovid-en-kultursjukdom/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 11 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/2762cbe8-764f-476b-a447-98f8f8135ba2"    target = "_blank"    class  = "screen-reader-friendly"    title. = "Version som fungerar bättre med skärmläsarprogramvara">  <i class="fas fa-volume-up"></i>  <span>Skärmläsarvänlig</span></a></div><div class="in-short-wrapper closed" id="in-short-168687">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "168687"></span>    <i class="themify-icon-icon fas fa-align-left"></i>    <span class="in-short-heading">I korthet</span>    <hr class="in-short-divider" />    <div class="in-short-text">    </div>  </div></div><div class="article-beginning ">– Jag tror jag vet vad det kan vara, utbrast min patient triumferande när han klev in på min mottagning.</p>
<p>Det var första gången på länge jag hade sett honom le. För ett halvår sedan hade min patient, som jag kommer att kalla <strong>Sven</strong>, insjuknat i en vanlig luftvägsinfektion. Febern och hostan gick över snabbt, men Sven blev aldrig densamma igen.</p>
</div>
<div class="rest-of-article ">
<p>Innan sjukdomen jonglerade han ett krävande jobb, två små barn och en passion för maratonlöpning. Nu blev han utmattad av minsta ansträngning. Ett banalt gräl med hustrun eller en halvtimme framför datorn gav honom huvudvärk, och en promenad i uppförsbacke kunde slå ut honom helt. Vid knappt 40 års ålder levde Sven som en bräcklig åldring.</p>
<p>Sven hade utretts grundligt, men prover och undersökningar låg inom det normala. I brist på andra hypoteser fick han diagnosen <em>postinfektiöst tillstånd</em> efter covid-19, mer känt som <em>postcovid</em>. Men Sven fortsatte envist att söka efter andra svar, på jakt efter något som gick att bota.</p>
<p>– Jag uppfyller praktiskt taget alla kriterier, förklarade Sven.</p>
<p>Han satte på sig sina läsglasögon och läste noggrant från en medhavd papperslapp:</p>
<p>– Det heter <em>my…algisk encefalo…myelit</em>. Har du hört talas om det?</p>
<p>Min blick föll mot bordet framför mig och jag svalde en djup suck. Jag berömde Sven för hans detektivarbete men förklarade att det inte spelade någon roll om han har myalgisk encefalomyelit eller postcovid, eftersom vi läkare är lika aningslösa om båda tillstånden. Och i vilket fall som helst så finns det ingen behandling för någotdera.</p>
<p>Sven nickade tyst, vek ihop sin papperslapp och sjönk tillbaka ner i stolen.</p>
<h2>Kultursjukdom eller inte?</h2>
<p>Patienter som Sven finns över hela Sverige. Två av dem – småbarnspappan <strong><a href="https://kvartal.se/artiklar/folksjukdomen-som-sverige-inte-latsas-om/">Staffan Danielsson</a> </strong>och läkaren <strong><a href="https://kvartal.se/artiklar/lakare-med-postcovid-jag-saknar-den-jag-var/">Lisa Norén</a></strong> – har delat sina erfarenheter i Kvartal. Trots sina förlamande symtom möts de ofta av misstro. Skribenten och sjuksköterskan <strong>Hanne Kjöller</strong> har i en <a href="https://www.dn.se/ledare/hanne-kjoller-specialistkliniker-for-kultursjukdomar-fungerar-som-fortidspensioneringsfabriker/">serie </a><a href="https://kvartal.se/artiklar/langtidscovid/">artiklar</a> beskrivit postcovid som en ”kultursjukdom” snarare än en riktig åkomma som gikt eller scharlakansfeber. Detta har utlöst en hätsk debatt mellan patienter å ena sidan och Kjöller å den andra. Vem har rätt?</p>
<p>Vi återkommer till det. Låt oss först göra en historisk återblick och reda ut några viktiga begrepp.</p>
<p>På 1950-talet beskrev den brittiske läkaren <strong>Melvin Ramsay</strong> en grupp patienter med plötslig trötthet, kognitiva svårigheter och muskelsmärta, vanligen i efterförloppet till en infektion. Han kallade tillståndet <em>myalgisk encefalomyelit</em>, vilket betyder ”inflammation i hjärna och ryggmärg med muskelsmärta”. Termen speglade Ramseys hypotes att sjukdomen orsakades av en inflammatorisk process.</p>
<p>När studier misslyckades med att hitta bevis för inflammation i nervsystemet började patienterna i allt högre grad hänvisas till psykiatrin, och termen ME ersattes av <em>kroniskt trötthetssyndrom</em> (CFS). Många patienter ansåg dock att den nya benämningen förminskade deras lidande och ogillade att klassas som psykiskt sjuka. Det framgick också snart att psykiatrin inte hade någon effektiv behandling mot CFS. Patienterna hamnade mellan stolarna, och verkade inte höra hemma någonstans. I brist på bättre idéer så började man kalla deras tillstånd för ME/CFS – en kompromiss mellan två problematiska begrepp.</p>
<p>I början av 2020-talet började termerna <em>postcovid</em> och <em>long covid</em> användas för att beskriva patienter med svår trötthet och kognitiva symtom efter en infektion med covid-19. De experter jag kontaktade för denna artikel betraktar ME/CFS och postcovid som nära besläktade, eller rentav samma sjukdom. De allra flesta fall verkar utlösas av infektioner, men symtom har i enstaka fall rapporterats i anslutning till förlossningar, olyckor, kirurgiska ingrepp och vaccinationer.</p>
<p>Listan över åkommor som liknar ME/CFS skulle kunna göras betydligt längre och inkludera tillstånd som Gulfkrigssyndromet och kronisk borrelia – en kontroversiell diagnos som inte erkänns av läkarkåren. Även personer som säger sig vara överkänsliga mot elektricitet rapporterar symtom som trötthet och hjärndimma. Här kommer jag dock att fokusera på de mer etablerade diagnoserna ME/CFS och postcovid.</p>
<p>När jag hänvisar till dessa tillstånd kommer jag för enkelhetens skull att använda ordet <em>sjukdomen</em> i kursiv stil.</p>
<h2>Tre kärnsymptom</h2>
<p>Hur vet man om man har <em>sjukdomen</em>? Sedan 1980-talet har dussintals samfund publicerat sina egna diagnostiska kriterier, med varierande innehåll. De flesta experter fokuserar dock på tre kärnsymtom: känslighet för ansträngning, kognitiva svårigheter och ortostatisk intolerans – där det autonoma nervsystemet har svårt att reglera hjärtrytmen när man reser sig upp. Patienter med detta slags besvär får ibland diagnosen POTS (<em>postural orthostatic tachycardia syndrome</em>), vanligen av en kardiolog.</p>
<p>De diagnostiska kriterierna för ME/CFS och postcovid bygger huvudsakligen på symtom snarare än objektiva fynd. Labbprover och röntgenbilder är ofta normala eller bara marginellt avvikande. Det betyder dock inte att objektiva fynd saknas. Vissa patienter har förhöjda nivåer av immunologiska markörer i blod eller ryggmärgsvätska. Andra har avvikelser på EKG eller minskad volym av vit hjärnsubstans på bilder tagna med magnetkamera. Kruxet är att fynden varierar kraftigt, utan något tydligt mönster.</p>
<blockquote><p>Vi har alltså tre experter med vitt åtskilda teorier och fyra helt olika läkemedel som de testar.</p></blockquote>
<p>Forskningen strävar efter att identifiera kliniskt användbara biomarkörer, men än så länge är labbprover och röntgenbilder sällan till någon nytta för läkare som träffar patienter med sjukdomen.</p>
<h2>Forskning med divergerande teorier</h2>
<p>Hur uppstår egentligen <em>sjukdomen</em>, och vad för slags forskning bedrivs på området? För att reda ut dessa frågor har jag konsulterat tre tunga experter.</p>
<p><strong>Petter Brodin</strong> är professor i pediatrisk immunologi vid Karolinska Institutet. Han är djupt engagerad i studier kring postcovid och misstänker att virus som covid-19 kan leva kvar i kroppen långt efter <em>sjukdomens</em> akuta fas – ibland i månader eller till och med år. Ett fynd som stödjer Brodins hypotes är att man har funnit spår av viruset hos 20–30 procent av patienter med postcovid. Brodin hoppas att det antivirala läkemedlet Paxlovid ska kunna hjälpa denna patientgrupp.</p>
<p><strong>Jonas Bergquist</strong>, professor i analytisk kemi vid Uppsala universitet, är öppen för tanken att <em>sjukdomen</em> kan orsakas av latenta virus i kroppen. Men i sin forskning fokuserar han på en tänkbar autoimmun och inflammatorisk process i nervsystemet. Just nu studerar han två läkemedel mot ME/CFS – Mestinon och Naltrexon. Mestinon hämmar nedbrytningen av signalsubstansen acetylkolin, och används för att behandla nervsjukdomen <em>myasthenia gravis</em>. Naltrexon används vanligen för att dämpa alkoholsuget hos personer med alkoholberoende, men har även något slags antiinflammatorisk effekt i hjärnan.</p>
<p><strong>Dr Klaus Wirth</strong> är professor i farmakologi vid Frankfurts universitet. Wirth tror att <em>sjukdomen</em> orsakas av en störning i mitokondrierna – de små ”kraftverk” i kroppens celler som producerar energi. Denna störning orsakar nedsatt blodcirkulation och syrebrist i muskelvävnader, vilket ger upphov till ett skadligt överskott av natrium och kalcium i cellerna. För att motverka denna process har Wirth och hans team utvecklat en molekyl vid namn MDC002, som bland annat reglerar nivåer av kalcium i cellen och dess mitokondrier.</p>
<p>Vi har alltså tre experter med vitt åtskilda teorier och fyra helt olika läkemedel som de testar. En lång rad andra hypoteser och tänkbara behandlingar hade kunnat nämnas, men då hade artikeln blivit alldeles för lång.</p>
<p>Vilken av våra tre experter har rätt? Kanske alla. Eller ingen. Bara tiden kan ge oss svaret. En sak som förenar samtliga är en tro på att deras forskning kan leda till ett genombrott. Detta borde inte överraska någon – kronisk optimism är utbredd bland forskare. Om de inte var optimister så hade de sysslat med något annat.</p>
<p>Å ena sidan är det glädjande att forskningen tar så många olika vägar och att så många läkemedel testas. Å andra sidan speglar denna spretighet en djuplodande förvirring om <em>sjukdomens</em> natur och orsak.</p>
<p>– När flera olika botemedel föreslås mot en åkomma så betyder det att åkomman inte går att bota, konstaterar <strong>Gajev </strong>i <strong>Anton Tjechovs </strong>pjäs <em>Körsbärsträdgården</em>.</p>
<p>Gajev syftade på den ryska aristokratins förfall, men hade lika gärna kunnat tala om <em>sjukdomen</em>.</p>
<h2>Beroendeframkallande utredningar</h2>
<p>Hur bör patienter med <em>sjukdomen</em> utredas? Frågan saknar entydigt svar, och praxis skiljer sig mellan olika länder och sjukvårdssystem. I sin bok <em>The invisible kingdom: Reimagining chronic illness</em> (Riverhead Books 2022) beskriver den amerikanska författaren <strong>Meghan O’Rourke</strong> sin tio år långa kamp mot en odefinierad åkomma som starkt påminner om <em>sjukdomen</em>.</p>
<p>Under denna tid möter hon dussintals läkare som ordinerar blodprover, ultraljud, tomografier, neurografier, lumbalpunktioner, mikrobiologiska analyser och MR-undersökningar till en kostnad av hundratusentals dollar. O’Rourke ordineras även en lång rad experimentella behandlingar, varav ingen fungerar. Vid bokens slut är hon betydligt fattigare, men lika ovetande om sin åkomma som förut. Trots detta vädjar hon ivrigt om fler medicinska utredningar för patienter som henne själv.</p>
<p>Meghan O’Rourkes slutsats kan verka ologisk, men är förståelig. För desperata patienter kan medicinska utredningar bli som en beroendeframkallande jakt på svar, särskilt när läkaren lovar att ”fortsätta leta tills vi hittar något”. I USA har <em>sjukdomen</em> blivit big business och omsätter flera miljarder dollar årligen. Dålig evidens är inget hinder så länge kunden skriver under på rätt rad.</p>
<p><em>Sjukdomens</em> låga status i samhället driver också efterfrågan på undersökningar. Patienter får ofta höra att deras symtom är inbillade eller ”sitter i psyket” och hoppas att objektiva fynd ska stärka deras trovärdighet och öppna dörrar till fler specialister. Men detta är vanligen en tom förhoppning. Inför <em>sjukdomen</em> står professorer och  världsledande forskare lika handfallna som husläkare eller psykiatrer. Gränsen mellan kropp och själ – somatik och psykiatri – blir dessutom allt suddigare och mindre relevant i takt med att forskningen rör sig framåt. Även psykiska sjukdomar är ju i grunden organiska, och hjärnan blott en fettklump full med elkablar.</p>
<blockquote><p>Hypersexualitet? Adhd. Impotens? Också adhd. Allt kan vara adhd.</p></blockquote>
<p>I USA handlar sjukvård om att göra kunden nöjd, medan vår svenska modell prioriterar att hjälpa så många som möjligt inom ramarna för en gemensam budget. I ett sådant system finns inget utrymme för dyra undersökningar med låg medicinsk nytta. Att utreda specifika symtom och utesluta farliga sjukdomar är ofta befogat, men när diagnosen väl är ställd fyller ytterligare utredningar sällan någon funktion. Som Staffan Danielsson korrekt <a href="https://kvartal.se/artiklar/folksjukdomen-som-sverige-inte-latsas-om/">påpekade</a> i Kvartal är tillstånd som postcovid numera folksjukdomar – välbekanta för de flesta läkare.</p>
<p>Att behandla varje patient som ett medicinskt mysterium à la tv-serien <em><a href="https://sv.wikipedia.org/wiki/House_(TV-serie)">House</a></em> är inte rimligt, särskilt när effektiv behandling ändå saknas.</p>
<h2>Kultursjukdom?</h2>
<p>Finns <em>sjukdomen</em> egentligen på riktigt? Eller är tillstånd som postcovid snarare uttryck för ett slags kollektiv ängslan bland högutbildade västerlänningar, som Hanne Kjöller antyder? Frågan är komplex och kräver en djupare diskussion än vad jag kan erbjuda här. På rak arm skulle jag själv inte beskriva postcovid som en kultursjukdom. Men det kan mycket väl bli en på sikt.</p>
<p>Låt mig förklara genom att jämföra två andra sjukdomar. Vi börjar med <em>fokal segmentell glomeruloskleros</em> (FSGS), en sällsynt njuråkomma som orsakar proteinläckage i urinen. Diagnosen ställs enbart av njurläkare efter ett flertal biopsier.</p>
<p>FSGS är helt okänd för allmänheten. Kvällstidningar har aldrig larmat för att läsarnas trötthet ”kan vara dold FSGS”. Ingen kändis har talat ut om sin FSGS i Hänt Extra. Ingen skum privatklinik erbjuder snabb FSGS-utredning – nu helt via nätet. FSGS är definitivt inte en kultursjukdom.</p>
<p>Låt oss nu titta på adhd. På 1990-talet ställdes diagnosen främst på en liten grupp barn med extremt stökigt beteende i skolan. Sedan dess har adhd exploderat över hela västvärlden. I vårt land delas diagnoser ut i rasande takt till nästan vem som helst. I media beskrivs adhd som svaret på alla livets frågor. Dålig sömn? Adhd. Känsla av otillräcklighet? Adhd. Hypersexualitet? <a href="https://www.verywellhealth.com/working-through-adhd-and-hypersexuality-in-relationships-5207993">Adhd</a>. Impotens? Också <a href="https://www.healthline.com/health/adhd/adult-adhd-sex-life">adhd</a>. Allt kan vara adhd.</p>
<p>En följd av denna massiva marknadsföring och diagnostik är att adhd inte längre tas på något större allvar, vare sig av läkare eller allmänhet. Om uppåt halva befolkningen har adhd så förlorar begreppet sin innebörd, och blir synonymt med allmänt sjaskigt mående. adhd är på god väg att bli en kultursjukdom.</p>
<blockquote><p>De bästa råden är nog att äta nyttigt, hålla modet uppe och att ta en dag i taget.</p></blockquote>
<p>Vissa med diagnosen postcovid verkar anta att deras ställning skulle stärkas om de bara vore fler. I Kvartal uppmuntrar Staffan Danielsson det svenska folket att härleda fler av sina hälsoproblem – ”allt från synfel, hjärnskador, tinnitus och domningar till nya allergier, magont och oregelbunden mens” – till covid-19. Om bara fler fick diagnosen så skulle postcovid tas på större allvar, hoppas Danielsson.</p>
<p>Mer troligt är att begreppet skulle urholkas och förlora all sin tyngd.</p>
<p>Att en diagnos blir populär skapar också problem för forskningen. Petter Brodin är ”övertygad om att det finns en kärna av patienter med uppenbar objektivt observerbar patologi som följer på infektion, det vill säga en postinfektiös sjukdom”. Men han tror också att utbredningen av postcovid är kraftigt överdriven och att många med diagnosen egentligen har andra besvär. Som forskare måste Brodin ständigt sålla bland patienter för att hitta dem som är av vetenskapligt intresse. Ju fler som får diagnosen, desto mer tid och resurser går åt till att sortera bort tveksamma fall.</p>
<h2>Åtgärder för patienterna</h2>
<p>Hur bör vi som samhälle förhålla oss till personer som lider av <em>sjukdomen</em>? Med respekt och empati. Ingen väljer att drabbas, och patienternas lidande är verkligt. ”Kultursjukdom” är ett intressant och värdefullt begrepp, men har i folkmun blivit synonymt med inbillningssjuka. I debatten om postcovid gör det mer skada än nytta och bör undvikas.</p>
<p>Även sjukvården har skäl att agera med ödmjukhet. Historiskt sett har vi läkare varit dåliga på att bemöta patienter vars symtom vi inte kan förklara eller lindra. Sådana patienter avfärdades länge som tokiga och hänvisades till psykiatrin. Denna praktik var sällan till nytta för patienterna, men skyddade läkarkårens självbild som allvetande. Att detta slags patienter numera hänvisas till primärvården är ett framsteg, om än ett blygsamt sådant.</p>
<p>Vad kan patienter med <em>sjukdomen</em> göra? Inte särskilt mycket i nuläget. Att tjata till sig en massa undersökningar leder sällan någonvart. Att bedriva aktivism och sprida kunskap om sin åkomma kan vara värdefullt, men riskerar att bidra till diagnosinflation. De bästa råden är nog att äta nyttigt, hålla modet uppe och att ta en dag i taget. Delta gärna i forskning om ni får möjlighet. Försök hitta en förstående husläkare som kan hjälpa till med intyg och rehabilitering. Kom ihåg att ni inte är bortglömda av sjukvården.</p>
<p>Vi ser er kamp och hoppas snart kunna erbjuda något som hjälper.</p>
<p><em>Vissa uppgifter i texten har ändrats för att värna om patienters integritet.</em></p>
<div class="author-byline">Erik W. Larsson är legitimerad läkare och specialist inom psykiatri, samt ST-läkare inom allmänmedicin.
</div>
</div>
