Gammelmedias sista strid?

<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-164395"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="1898" data-tin="2014" data-pid="164395" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="R2FtbWVsbWVkaWFzIHNpc3RhIHN0cmlkPw==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xNy00NC1nYW1tZWxtZWRpYXMtc2lzdGEtc3RyaWRfLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTctNDQtZ2FtbWVsbWVkaWFzLXNpc3RhLXN0cmlkXy5tcDM=">  <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: ">Av <a href="https://kvartal.se/medverkande/jens-ganman/">Jens&nbsp;Ganman</a> | 28 januari 2025<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%2Fgammelmedias-sista-strid%2F&amp;t=Gammelmedias+sista+strid%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=Gammelmedias+sista+strid%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fgammelmedias-sista-strid%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%2Fgammelmedias-sista-strid%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Gammelmedias sista strid?&body=https://kvartal.se/artiklar/gammelmedias-sista-strid/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/164395/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="kv-art-ext-sep"></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%2Fgammelmedias-sista-strid%2F&amp;t=Gammelmedias+sista+strid%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=Gammelmedias+sista+strid%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fgammelmedias-sista-strid%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%2Fgammelmedias-sista-strid%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Gammelmedias sista strid?&body=https://kvartal.se/artiklar/gammelmedias-sista-strid/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/164395/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/gammelmedias-sista-strid/?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 21 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/447a53c3-bf98-4a38-8776-f9f8b85fc89c"    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-164395">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "164395"></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 ">Under <strong>Bidens</strong> presidentskap tappade ansedda <em>Washington Post</em> 90 procent av sin digitala läsning.<sup>1</sup></p>
<p><em>MSNBC</em> ligger i stupstocken och enligt <em>CNN</em>:s förra vd <strong>Chris Licht</strong> har allmänheten tappat förtroende för traditionella medier. De lever på ärvda meriter (därav ”legacy media”). <em>CNN</em> – den kanal som inspirerat SVT:s USA-bevakning – har låg och sjunkande räckvidd. Förra månaden snittade man 69 000 dagliga tittare i kategorin 25 till 54 år, i ett land med 350 miljoner invånare.<sup>2</sup></p>
<p>Vad beror det på? <strong>Trumps</strong> envetna tjatande om ”fake news”? <strong>Musks</strong> oberäkneliga avtryckarfinger på X? Eller rätt och slätt på journalisternas oförmåga att förstå och acceptera den nya världsordningen?</p>
</div>
<div class="rest-of-article ">
<p>* * *</p>
<p class="p1">År 1974 lanserade den tyska statsvetaren <strong><span class="s2">Elisabeth Noelle-Neumann</span></strong> något hon kallade för “tystnadsspiralen”. Hennes teori går ut på att folk helst inte säger högt vad de egentligen tycker om saker – såvida de inte är säkra på att alla andra tycker likadant. Noelle-Neumann menar att om alla mörkar sina verkliga åsikter så uppstår en falsk majoritet. En destruktiv tystnad breder ut sig; konformismen och fegheten segrar.</p>
<p class="p1">I Sverige döptes fenomenet till ”åsiktskorridoren”.</p>
<p class="p1">Expressens <b>Ann-Charlotte Martéus </b>erkände redan 2015 att det var hon och hennes journalistkollegor som rest stommen till denna korridor.<sup>3</sup></p>
<p class="p1">Vissa menade att hon hade fel – att man får tycka precis vad man vill, även om det såklart kan kosta att ha ”fel” åsikt. Eller som <b>PJ Anders Linder </b>uttryckte saken: ”Den som påstår att det inte finns en åsiktskorridor har aldrig haft en obekväm åsikt.”<sup>4</sup></p>
<h2 class="p1">Ett öppet brev</h2>
<p class="p1">”Spaltdåre”, ”konspirationsteoretiker”, ”radikaliserad”, ”utelämnar information om Trumps kopplingar till nazism”.</p>
<p class="p1">Kommentarer som dessa, och liknande, fälldes i samband med att Handelsbankens nyhetssajt EFN i somras värvade SvD:s avhoppade USA-korre <b>Malin Ekman</b>.<sup>5,</sup><sup>6</sup></p>
<p class="p1">Ekmans rockad väckte indignation hos vissa, skadeglädje hos andra. Tidningen Journalisten kallade avhoppet för ”bullrigt” – kanske för att Ekman skrev ett öppet avskedsbrev i samband med sin sorti, ett brev där hon kritiserade den låga takhöjden hos SvD, och indirekt chefredaktören <b>Lisa </b><b>Irenius</b>.<sup>7</sup></p>
<p class="p1">Andra kollegor, framför allt manliga, menade att Ekman var Trump-apologetiker och en fara för journalistiken – och i förlängningen för demokratin.</p>
<p class="p1">Lite som när CNN kallade <b>Mike Pence</b> för Trumps ”<em>apologizer-in-chief</em>”.<sup>8</sup></p>
<p class="p1">Jag vet inte om skribenterna på Aftonbladet och Dagens Nyheter får precis <i>all </i>sin information om USA från <em>CNN</em>, men gissningsvis kommer en del därifrån. Vilket möjligen är ett problem i sammanhanget, på samma sätt som att Fria Tider och Samnytt får <i>sin</i> information från <em>Fox News</em>.</p>
<p class="p1">När ”alternativjournalisterna” på <i>Project Veritas</i> smygfilmade en av <em>CNN</em>:s ”technical directors” <b>Charlie Chester</b> 2023<sup>9</sup> om hur hans arbetsgivare porträtterade Donald Trump sa han så här:</p>
<p class="p1">– Vid ett tillfälle kunde man se hur Trumps hand skakade. Vi (<em>CNN</em>) tog in massor av medicinskt kunniga personer för att väva en story som var ren spekulation – att Trump hade en hjärnskada och höll på att tappa det. Att han var olämplig (som president). Vi skapade en story vi inte visste ett dugg om. Jag skulle kalla det propaganda.<sup>10</sup></p>
<p class="p1"><b>Joe Biden</b> skulle däremot, enligt Chester, framställas som ”ungdomlig” och sportig; där valde <em>CNN</em> helst bilder och klipp där den 82-årige presidenten småjoggade fram och bar coola solglasögon.</p>
<p class="p1">Apropå oberoende journalistik och hot mot demokratin.</p>
<h2 class="p1">Vem är syndabocken?</h2>
<p class="p1">I riksdagsmotion 1714 24/25 står följande att läsa:</p>
<p class="p1" style="padding-left: 40px;"><i>”Sverige är ett mångkulturellt land präglat av mångfald och förståelse, men </i><i>trots det ser vi en tydlig uppdelning mellan &#8217;vi&#8217; och &#8217;dem&#8217;. </i><i>Denna uppdelning, som ständigt förstärks genom media och politiska </i><i>diskurser, påverkar inte bara samhällsklimatet utan även individers välbefinnande. </i><i>Människor påverkas avsevärt negativt av denna ständiga gränsdragning, när </i><i>olika grupper pekas ut som syndabockar.”</i></p>
<p class="p1">Det är så sant som det är sagt. Det <i>pågår </i>en ständig gränsdragning i vårt land. En noggrann uppdelning mellan ”vi” och ”dom” som inte sällan eldas på av medierna: svart mot vit, röd mot blå, god mot ond, traditionella medier mot ”alternativa” sådana. I det senare fallet stöts kättarna ut, även om de en gång befunnit sig längst in i etablissemangets varma kärna. Han som skrev raderna längst upp i stycket borde veta. Hans namn är <strong>Jamal El-Haj</strong>.</p>
<p class="p1">El-Haj skrev motionen innan han avslöjades som Hamaskramare och fick silkessnöret av <b>Magdalena Andersson.</b> Gissningsvis syftade han<i> </i>inte på dynamiken mellan gammel- och alternativmedier när han talade om det där med ”syndabockar”, men principiellt sett hade han rätt: olika grupper pekas ut och det är inte bara muslimer. Ibland händer det att även enskilda människor får löpa gatlopp.</p>
<p class="p1">Efter att författaren <b>Katerina Janouch</b> – som privatperson – ställt upp på en intervju i tjeckisk tv 2017 och ”svartmålat Sverige” ryckte SVT Kultur ut och fact-checkade allt hon sagt med en nit som skvallrade om att de tagit hennes utsagor personligt.<sup>11</sup></p>
<p class="p1">Till och med statsminister <b>Stefan Löfven </b>kände sig den gången manad att ge Janouch smäll på fingrarna. Nationens rykte stod på spel.<sup>12</sup></p>
<p class="p1">Och journalistikens.</p>
<p class="p7">Precis som när <b>Malin Ekman </b>sa upp sig med motiveringen att hennes chefer försökte styra hennes texter. Till exempel när hon, inför det amerikanska presidentvalet, försökte ”förvarna&#8221; den svenska publiken om att <span class="s3">många svarta väljare nog tänkte lägga sin röst på Donald Trump. Den texten tog två månader att publicera, </span>med motiveringen att den utgjorde ”Trump-propaganda”, enligt Ekman. En intressant invändning, för även om den skulle äga sin riktighet är det svårt att förstå varför svenska medier ska bry sig om vad som eventuellt spelar en amerikansk presidentkandidat i händerna eller inte. Vad en svensk journalist skriver i SvD påverkar knappast världspolitiken.</p>
<figure id="attachment_164867" aria-describedby="caption-attachment-164867" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="size-full wp-image-164867" src="https://kvartal.se/wp-content/uploads/2025/01/Malin.jpg" alt="" width="1024" height="576" data-wp-pid="164867" srcset="https://kvartal.se/wp-content/uploads/2025/01/Malin.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/01/Malin-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/Malin-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/Malin-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/01/Malin-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-164867" class="wp-caption-text"><em>Malin Ekman. Foto: Emma-Sofia Olsson/SvD/TT</em></figcaption></figure>
<p class="p7">Till slut fick Malin Ekman nog av hårklyverierna och skrev det uppmärksammade ”Dear John”-brevet till hela branschen, som publicerades på hennes Substacksida <a href="https://stockholmreport.substack.com/"><em>Stockholm Report</em></a>, där hon idag fortsätter bevaka amerikansk politik.</p>
<p class="p7">En som reagerade kraftigt på Ekmans ställningstagande var författaren <b>Martin Gelin</b>. Han skrev i Dagens Nyheter om tidningen Journalistens intervju med Ekman:</p>
<p class="p7"><i>”&#8230;intervjun ackompanjeras av rubriken att Trump &#8217;inte ljuger mer än andra&#8217; </i><i>politiker. Inne i tidningen påstår Ekman att Trump &#8217;överdriver men har ofta rätt&#8217;.”<sup>13</sup></i></p>
<p class="p7">Gelin lade till ”att Trump inte ljuger är ingen åsikt. Det är ett faktafel”. Och gled därmed själv direkt på sanningen eftersom han utelämnade ”mer än andra” i sitt påstående. Vilket är en väsentlig skillnad: att ”inte ljuga” och ”inte ljuga mer än andra”.</p>
<p class="p7">När jag i efterhand frågar Malin Ekman om hur det kändes att bli påhoppad från så många håll säger hon:</p>
<p class="p7">– Det var helt absurt. Som att hela världen var upp och ner. Inte nog med att Martin Gelin fultolkade mig – jag <i>sa</i> inte ens så i tidningen Journalisten! Alltså att Trump inte ljuger mer än andra. Det är deras <i>tolkning </i>av det jag sa.</p>
<p class="p7"><b>Varför tror du att USA-bevakningen post 2016 blev så komplicerad </b><b>för svenska medier?<br />
</b>– Jag tror att man förväntade sig, och nästan ”ville”, att utvecklingen skulle se ut på ett visst sätt, och när den inte gjorde det, utan tvärtom visade sig mer komplicerad – från hur Trumps väljarbas såg ut till hur ofta radikal vänsterideologi påverkar alltifrån grundskolor till universitet och storföretag, eller hur kriminalitet och utsatthet följer progressiv politik – så valde man i stort att bortse från det och i stället fortsätta beskriva verkligheten efter sin egen förklaringsmodell. Det där skapade ett större avstånd mellan människor och nyhetsmedier, eftersom de inte känner igen sig i det de läste, såg eller tittade på i traditionella kanaler.</p>
<h2 class="p7">30 minuter: Holmberg vs Jönsson</h2>
<p class="p1">Under tiotalet dök fler och fler konträra röster upp i den svenska samhällsdebatten. Röster som påpekade att allt kanske inte såg ut – eller fungerade – som SVT, SR, DN, Flamman och de andra ville göra gällande. Det kunde ju inte vara normalt att lilla Sverige har flest bombdåd av alla icke-krigförande länder i världen, näst efter Mexiko?<sup>14</sup></p>
<p class="p1">Och att vi plötsligt har runt 800 000 analfabeter utspridda över hela landet?<sup>15</sup></p>
<p class="p1">Något måste ha gått allvarligt snett?</p>
<p class="p1">De som satt inne i värmen och smorde kråset stirrade ut på orosmakarna med irriterad blick. Lite som i <b>Albert Engströms </b>gamla skämtteckning ”Scen från Operakällaren” där uteliggaren glor in på parnassen och med ett retsamt leende höjer sin ölflaska till skål.</p>
<p class="p1">Jag tänker osökt på <b>Henrik Jönsson</b> och <b>Anders Holmberg</b> när jag ser den och på den redan klassiska intervjun i <em>30 minuter</em> där nästan hela programtiden ägnades åt ett enda klipp i en av Jönssons hundratals Youtube-videor. Jönssons fans menar att det var småaktigt av SVT att hänga upp sig på just den detaljen, speciellt som han ju hade rätt i sak (<b>Erika Bjerström </b>gillar inte Donald Trump).</p>
<figure id="attachment_164877" aria-describedby="caption-attachment-164877" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="size-full wp-image-164877" src="https://kvartal.se/wp-content/uploads/2025/01/Henrik-1.jpg" alt="" width="1024" height="576" data-wp-pid="164877" srcset="https://kvartal.se/wp-content/uploads/2025/01/Henrik-1.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-1-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-1-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-1-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-1-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-164877" class="wp-caption-text"><em>Henrik Jönsson. Foto: Privat</em></figcaption></figure>
<p class="p1">Hans belackare menar att klippet är representativt för <i>allt</i> han producerat; <i>allt</i> han gör är bluff och båg. Det är svårt att ha invändningar mot programmet i sak och rimligtvis förstod Henrik Jönsson vad han ställde upp på. Han borde ha tagit avstånd från den där fulklippningen på en gång, i stället för att försöka resonera sig ur det; oavsett om Erika Bjerström faktiskt tycker som hon tycker om Donald Trump.</p>
<p class="p1">Anders Holmberg å sin sida tog chansen att ge igen för gammal ost. I åratal har Henrik Jönsson kritiserat statsmedierna för deras vänsterlutning och deras eget dribblande med fakta. Nu hade han fulklippt Holmbergs kollega i ett inslag som handlade SVT:s USA-bevakning och givetvis fick han skit för det. Inte minst <i>efter</i> att programmet hade sänts. Skadeglädjen – och den oförblommerade ilskan – bland gammelmedias journalister visste inga gränser.</p>
<p class="p7"><span class="s4"><b>Peter Kadhammar</b> skrev så här i Aftonbladet:</span></p>
<p class="p7"><span class="s4">”</span><i>Henrik Jönsson heter en borgerlig så kallad influencer som har beljugit SVT-</i><i>journalisten Erika Bjerström på det mest svinaktiga sätt.</i> <i>Jönsson lär vara en viktig </i><i>man i borgerligheten. Han har 153 000 prenumeranter på Youtube. Hans behandling </i><i>av Bjerström är därför intressant som tidsfenomen.”</i><sup>16</sup></p>
<p class="p7">Med tillägget:</p>
<p class="p7"><i>”En manipulering värdig ryska propagandister.”</i></p>
<p class="p7">Detta skriver Kadhammar i samma tidning som en gång hamnade i blåsväder för att en av deras journalister anlitat nazister för att fejka hotbilder utanför journalisten <b>Alexandra Pascalidous</b> dörr. Bilder som Aftonbladet publicerade och sedan högljutt försvarade, trots att de visste att det var fejk.<sup>17</sup></p>
<p class="p7">Det går (såklart) att hitta många andra exempel på när etablissemangsmedierna manipulerat<sup>18</sup> och ”beljugit<sup>19</sup> på det mest svinaktiga<sup>20</sup> sätt”.</p>
<p class="p7">Det verkligt intressanta här är dock Kadhammars apoplektiska reaktion. Står den i rimlig proportion till Henrik Jönssons kreativa klippning? Hans krönika formligen dryper av förakt:</p>
<p class="p7">”Jönsson (…) lär vara en viktig man (…) en så kallad influencer.”</p>
<p class="p7">Man får intrycket av en gammal farbror som aldrig tidigare sett en influencervideo, men som nu vaknat till och genast förstått att <i>a-l-l-t </i>på hela internet är bluff och båg. <i>Rysk propaganda! </i><i>Fi donc! </i></p>
<p class="p7">Fast Kadhammar menar ändå att Jönsson och hans sätt att bedriva alternativ journalistik är ”intressant som tidsfenomen” – och det är det. Problemet är att Kadhammar bara förmår att identifiera fenomenet – inte tolka det. Såna som Henrik Jönsson, och hans räckvidd på nätet, är inte ett tecken på att Tredje riket är i antågande eller att demokratin är hotad. Däremot tyder det på att såna som Aftonbladet och Peter Kadhammar spelat ut sin roll som informationsbärare med ensamrätt på samhällsanalysen.</p>
<p class="p7">Jag frågar Henrik Jönsson samma sak som jag frågade Malin Ekman: Hur känns det att få så oproportionerligt mycket däng i spalterna för att man antingen uttryckt en avvikande åsikt eller ”gjort fel”? Alltså fulklippt ett inslag på sin Youtubekanal – något som i Jönssons fall närmast likställs med att ramma sin bil in bland oskyldiga julfirare i Magdeburg eller New Orleans.</p>
<p class="p7"><strong>Varför tar svenska journalister i så att de spricker en sån här gång?<br />
</strong>– Jag gissar att det har att göra med att alla känner varandra, och de verkar ha en väldigt stark kåranda. Det framstår även som att avskyn mot Trump under inga omständigheter får nyanseras, utan till varje pris måste framhållas som en objektiv norm. De gamla medierna är i min mening inte beredda till ens en millimeter av självkritik, säger Henrik Jönsson.</p>
<p class="p7">Det är för övrigt inte jättemycket som skiljer Jönsson och Holmberg åt.</p>
<p class="p7">I alla fall inte på ytan. Två välklädda, välfriserade män i sina bästa år. Den ene statsfinansierad journalist, den andre fri opinionsbildare. Båda uppvuxna i samma land med samma värderingar; präglade av samma kulturella företeelser. Två vita priviligierade övre medelklassmän. Fast de har landat i helt olika slutsatser om hur man bäst påverkar samhällsutvecklingen. Jönsson startade en ”libertariansk” Youtube-kanal och lägger ut filmer som med en blandning av torr humor och fakta kritiserar olika samhällsföreteelser och inte minst: rödgröna politiker.</p>
<p class="p1">Holmberg valde att tjäna statstelevisionen.</p>
<p class="p1">Han leder SVT:s tyngsta debattforum (<em>30 minuter</em>) – koncernens svar på den globala trenden med maratonlånga diskussionspoddar. De där som aldrig får ”slut på tid” och som låter folk prata så länge de vill, tills alla ämnen är uttömda och publiken har fått en mer nyanserad bild av dagens gäst och ämne.</p>
<p class="p1">Eller somnat av tråkslag.</p>
<p class="p1">Donald Trump förstod kraften i fenomenet; coachad av sin tonårige son <b>Barron</b> besökte han under sin presidentvalskampanj<b> Joe Rogan, Theo Von, </b><em>Flagrant</em>, <em>Bussin’ with the Boys</em> och en rad andra oberoende, eller ”alternativa”, samhällskommentatorer.</p>
<p class="p1">Det kostade honom inte ett rött öre.</p>
<p class="p1">Samtidigt blåste motståndaren <b>Kamala Harris </b>en och en halv miljard dollar på gud-vet-vad. Hon var i och för sig också med i några poddar (<b>Howard Stern</b>, <i>Call her Daddy</i>, <i>Club Shay Shay</i> med flera), men bara i såna där hon visste exakt vilka frågor hon skulle få och där hon var säker på att hon talade till en redan frälst publik.</p>
<p class="p1">Vi vet hur det slutade.</p>
<h2 class="p1">”Han kan krypa tillbaka under sin sten”</h2>
<p class="p1">Såna som Henrik Jönsson och Malin Ekman driver tesen att den svenska allmänheten är delvis felinformerad om hur amerikansk inrikespolitik utvecklat sig sedan 2016. Andra menar att felinformationen inte stannar vid det, utan att ”gammelmedia” fört oss bakom ljuset i en rad andra frågor, som exempelvis sådana som rör covid-19, Palestinafrågan och – inte minst – klimatet. De flesta svenska nyhetskonsumenter vet att <strong>Greta Thunberg</strong> hävdar att havsnivåerna är på väg att stiga katastrofalt. Hur många har fått information om att en av Greenpeaces grundare, <b>Patrick Moore</b>, menar att hela klimatfrågan är en bluff – något som framtidens historiker kommer att skratta ut?</p>
<p class="p1">Jag vet inte om SVT har sänt ett inslag om detta, kanske har de gjort det, men i så fall är det inget som fått särskilt stort fäste i folks medvetande på det sätt som Gretas teser har. Under lång tid var Greta en ofta citerad ”expert” i svenska medier.</p>
<p class="p1">Samtidigt som debattörer som <b>Thomas Sowell, Larry Elder, Charlie Kirk</b> och <b>Katie Hopkins</b> i princip är okända för den breda massan i Sverige. Ingen av dem har gästat <strong>Skavlan</strong> eller <b>Carina Bergfeldt</b> och det är troligen ingen slump. Konservativa röster betraktas som farliga. Efter att <strong>Jordan B Peterson</strong> gästat just Skavlan sa vår dåvarande utrikesminister <strong>Margot Wallström</strong><sup>21</sup>:</p>
<p class="p1">– Han kan krypa tillbaka under sin sten.</p>
<p class="p1">Som vore han – en av vår tids skarpaste retoriker – en orm.</p>
<p class="p1">En kackerlacka.</p>
<h2 class="p7">SVT granskar förlaget Lava</h2>
<p class="p7">Hur är det då med anklagelserna att ”gammelmedia”, med SVT och SR i spetsen, på ett medvetet sätt formar ”narrativet”? Eller ljuger genom uteslutande av information? Har jag några konkreta bevis på det?</p>
<p class="p7">Ja, ett litet i alla fall. Under hösten har SVT Kultur lagt ner stora resurser på att granska förlaget Lava, som bland annat erbjuder sina klienter egenutgivning till självkostnadspris. Bland de publicerade författarna finns <b>Aron Flam, </b><b>Rebecca Weidmo Uvell,</b> <b>Katerina Janouch, Björn Törnvall </b>(<i>Jakten på </i><i>Karl </i><i>Hedin</i><i> – ett totalhaveri för rättvisan</i>, 2022) och jag själv. Men även namn som <b>Alexandra Pascalidou </b>och<b> Linnéa Engström </b>(<i>Klimatfeminism</i>, 2016).</p>
<p class="p7">Hittills har SVT producerat fem inslag om just detta förlag, och vinklingen har varit hård; Lava är ett förlag som ”luras” och sysslar med ”bondfångeri”. Eftersom jag själv publicerat på Lava (<em>Det lilla landet som kunde</em>, 2017, tillsammans med <b>Mustafa Panshiri</b>) har jag en bild av vad det innebär att egenpublicera: en massa jobb och massor av egen marknadsföring.</p>
<p class="p7">Jag hörde av mig till SVT och berättade att jag har erfarenhet av Lava och ville berätta om det. Reportern <b>Rebecca Lundberg</b> ringde upp och intervjuade. Möjligen utvecklade sig inte samtalet i den riktning hon trott/hoppats och efter ungefär fem minuter avbröt hon mig med en kontrollfråga:</p>
<p class="p7">– Det låter som du har ganska bra erfarenheter av Lava (och egenutgivning)?</p>
<p class="p7">Jag bekräftade att det fungerat hyfsat, men framför allt att det är mycket mer jobb med egenutgivning än folk i gemen kanske tror. Självfinansierad egenutgivning innebär <i>inte</i> att förlaget åtar sig att sälja 100 000 ex av ens bok, man får stå för i princip all marknadsföring själv och ofta åka runt och föreläsa för att på det viset sälja böcker.</p>
<p class="p7">Rebecca tackade för att jag hört av mig.</p>
<p class="p7">När jag frågar min tidigare förläggare <b>Peter Norrman</b> om varför han tror att SVT jagat just Lava så hårt under hösten säger han:</p>
<p class="p7">– I en bransch där det generellt sett är kroniskt ont om pengar finns en annan valuta som är branschens livsnerv – kredd. Kreddmaktsordningen ställer till det för företag som utmanar etablerade affärsmodeller och vad som anses vara fint och fult. Jag tror det kokar ner till fin- vs. fulkultur, säger Peter Norrman.</p>
<p class="p7">– Lava ligger långt ner i kreddmaktsordningen, SVT Kultur eller andra representanter från den ”goda sidan” skulle aldrig gå så här hårt åt aktörer som de ser som kolleger, jämlikar. Det handlar ytterst om socialt förakt och då blir det viktigt att signalera var man står. Det är trist att vissa av våra kunder inte varit nöjda, men de flesta är det.</p>
<figure id="attachment_164861" aria-describedby="caption-attachment-164861" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="size-full wp-image-164861" src="https://kvartal.se/wp-content/uploads/2025/01/Peter.jpg" alt="" width="1024" height="576" data-wp-pid="164861" srcset="https://kvartal.se/wp-content/uploads/2025/01/Peter.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/01/Peter-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/Peter-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/Peter-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/01/Peter-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-164861" class="wp-caption-text"><em>Lavas förläggare Peter Norrman. Foto: Hakan Unsal</em></figcaption></figure>
<p class="p4">Möjligen har han en poäng. Det där om bredden. Det är oklart vad SVT avslöjade med sin granskning, exakt, annat än att några författare inte varit nöjda med sitt förlagssamarbete. Och att medarbetarna på Lavas kontor i Riga själva valt att ha svenska namn på företagets sajt.</p>
<p class="p7">Helt klart finns det personer, företag och företeelser som stör det vi slarvigt kallar ”gammelmedia”. Sådana som Henrik Jönsson och Malin Ekman får oproportionerligt med gängstryk när de inte rättar in sig i ledet.</p>
<p class="p7">Att kritisera medieetablissemanget är <i>verboten</i> i Sverige, och sådana som Peter Kadhammar och hans kolleger uppvisar ibland en fascinerande snarstuckenhet över konkurrenter som inte beter sig ”som man ska”.</p>
<p class="p7">Lex Dumpen.</p>
<p class="p4">Få fristående medieprojekt har stört etablissemanget som just pedofiljägarna <b>Patrik Sjöberg</b> och <b>Sara Nilsson</b>. Aftonbladet och ETC driver tesen att Dumpen ”hänger ut” människor i strid med både <i>habeas corpus</i> och oskuldspresumtionen.</p>
<p class="p4">Det märkliga i sammanhanget är att även SVT och SR hängt ut två barnkära centerpolitiker: en i Arvidsjaur, en i Kungsör. Männen publicerades först på Dumpen, varpå public service – och Norran – hakade på med hänvisning till ”allmänintresset”.</p>
<p class="p4">Debatten kring SVT:s och SR:s häxbränningar uteblev.<sup>22,23</sup></p>
<h2 class="p7">Årets avslöjande eller Årets förvillare?</h2>
<p class="p4">År 2020 vann <b>Henrik Evertsson</b> Stora Journalistpriset för sin granskning av Estoniakatastrofen. I efterhand blev det ett visst rabalder kring det. Det gick så långt att jurymedlemmen <b>Patrik Hadenius </b>gick ut och tog avstånd från pristagaren.<i> </i></p>
<figure id="attachment_164863" aria-describedby="caption-attachment-164863" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-164863 size-full" src="https://kvartal.se/wp-content/uploads/2025/01/Henrik.jpg" alt="" width="1024" height="576" data-wp-pid="164863" srcset="https://kvartal.se/wp-content/uploads/2025/01/Henrik.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/01/Henrik-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-164863" class="wp-caption-text"><em>Henrik Evertsson. Foto: Björn Larsson Rosvall/TT</em></figcaption></figure>
<p class="p4">SVT satte ihop en egen motdokumentär där Evertssons arbete sablades ner som slarvigt och missvisande, fast dessförinnan hann regeringen allokera om 80 miljoner från MSB till fler dykningar kring Estonia. Något som gjorde att SVT i ett nyhetsinslag drog en parallell mellan MSB:s minskade anslag och raset vid E6 i Stenungsund 2023.</p>
<p class="p4">– Man tolkar det som att det där raset inte hade skett om det inte var för en dokumentärserien, konstaterar Henrik när jag intervjuar honom på länk från Norge där han bor.</p>
<p class="p4">– Att det raset utreds som misstänkt miljöbrott glömde man dock att nämna.</p>
<p class="p4"><b>Det har varit flera offentliga debatter om Estoniadokumentären, har du blivit inbjuden till nån av dem?</b><br />
– Nej, och det hade nog blivit ett annat samtal då. Det är synd, för som offer för ett av Europas värsta högerextrema terrorattentat i modern tid har jag engagerat mig djupt i att motverka radikalisering och konspirationsteorier. <i>(Evertsson splitterskadades i Anders Behring Breiviks bombdåd i centrala Oslo 2011, reds. anm.)</i>.</p>
<p class="p4"><b>Hur har åren efter dokumentären och Stora Journalistpriset varit?<br />
</b>– Att få både Stora Journalistpriset och Årets förvillare för samma arbete visar väl hur inflammerad Estoniakatastrofen är. Jag har alltid varit noga med att <i>inte </i>spekulera i hur skadan i skrovet uppkommit eller att den officiella historien inte är korrekt. En sak värd att nämna i sammanhanget är att SHK nu menar att M/S Estonia inte var sjöduglig när hon lämnade Tallinn. Det går stick i stäv med rapporten från 1997.</p>
<p class="p4"><b>SVT visade aldrig din dokumentär? Varför tror du att de valde bort den?</b><br />
– Som jag förstod det tyckte de inte att reportaget hade tillräckligt granskande ambitioner och det är helt okej – det är ingen mänsklig rättighet att ens reportage ska visas på SVT.</p>
<p class="p4">Konspirationsteoretikern i mig vaknar.</p>
<p class="p4">Jag funderar på om även Evertsson är en sån där obekväm typ som måste desavoueras för att han inte är en del av det omtalade ”klägget” i Stockholms journalistvärld. Han kommer från jämtländska Rödön. En klassisk katt bland hermelinerna, utan kompisar på rätt ställen.</p>
<p class="p4">Patrik Hadenius – som alltså satt med i juryn när Stora journalistpriset delades ut – är med i P1:s <em>Spanarna</em>. Det är <b>Jonathan Lindström</b> också. Och Lindström har fått pris som Årets folkbildare 2007 – av Vetenskap och Folkbildning, samma förening som tyckte att Evertsson är en ”förvillare”.<span class="Apple-converted-space">  </span>Spelar såna detaljer någon roll? Troligen inte, men lite pikant är det.</p>
<p class="p4"><b>Så här i efterhand – var det värt att göra Estoniadokumentären?<br />
</b>– Oj, det har jag aldrig funderat på. På 30-årsdagen för förlisningen i september i fjol hörde en stor grupp överlevande av sig och tackade mig för mitt bidrag till kunskapen om förlisningen. Jag brukar inte gråta, men då kom det en tår. För det är för dem – och de anhöriga som sökt ytterligare kunskap och förståelse – vi gjorde serien.</p>
<h2 class="p4">Klägghybrid?</h2>
<p class="p4">Jag känner att jag som avslutning på den här texten måste intervjua någon från det andra laget också – en representant för det berömda klägget, som <b>Håkan Juholt </b>(måhända oavsiktligt) döpte om gammelmedia till. Jag hör av mig till <strong>Jörgen Huitfeldt</strong> på Kvartal.</p>
<figure id="attachment_164866" aria-describedby="caption-attachment-164866" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-164866 size-full" src="https://kvartal.se/wp-content/uploads/2025/01/Jorgen.jpg" alt="" width="1024" height="576" data-wp-pid="164866" srcset="https://kvartal.se/wp-content/uploads/2025/01/Jorgen.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/01/Jorgen-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/Jorgen-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/Jorgen-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/01/Jorgen-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-164866" class="wp-caption-text"><em>Kvartals chefredaktör Jörgen Huitfeldt. Foto: Kvartal</em></figcaption></figure>
<p class="p4">Jag vet att det finns de som misstänker honom för att fortfarande vara mer ”public service” än ”nymedia”,<span class="Apple-converted-space">  </span>men i vilket fall är han en av få svenska journalister som sett båda sidorna av myntet. Han om någon borde kunna ge en rimlig analys av de svenska mediernas dagsform.</p>
<p class="p10"><b>Är svenska journalister och opinionsbildare, i allmänhet, för veka och ömhudade när det gäller kritik?<br />
</b>– Tveklöst ja. Jag har alltid tyckt att det är så konstigt att journalister, som begär av andra makthavare att de ska tåla hård kritik, är så otroligt snarstuckna när de själva blir föremål för granskning. Men det gäller också de som representerar de nya, alternativa medierna. Jag tycker exempelvis att Henrik Jönsson efter <em>30 minuter</em> framstod som lite onödigt kränkt. Det var väl bara att erkänna att han slarvat och lyfta på hatten för Anders Holmberg som gjorde sitt jobb.</p>
<p class="p10"><b>Du satt själv i juryn för Stora journalistpriset (det som Henrik Evertsson fick) och du är kompis med Anders Holmberg. Ser du dig som en representant för det utskällda klägget? Är Kvartal i själva verket ett slags ”klägghybrid”? Och i så fall: måste det vara dåligt?<br />
</b>– Klägghybrid är ett ganska träffande uttryck. För att kunna vara relevanta och komma till tals med dem som faktiskt har makten i det samhälle vi bevakar måste vi ha en fot i det som kallas ”klägget”, ja rent av vara en del av det. Tricket är att ändå inte komprometteras och att liksom försöka stå utanför och titta in.</p>
<p class="p10"><b>Och när det gäller gammelmedias framtid – hur fort tror du att det kommer gå? Överdriver alarmister som jag eller kommer det gamla paradigmet att göra comeback när svallvågorna lagt sig och folk tröttnat på att läsa Elon Musks tweets fem gånger om dagen?<br />
</b>– Det är frågan. Jag har visserligen många gånger fått äta upp min dödförklaring av papperstidningen, som obegripligt nog överlevt fram tills nu. Samtidigt är det en jordbävning i slow motion som drar fram över mediesamhället. Jag tror att de gammelmedier som förmår att anpassa sig till det nya kan överleva medan de som försöker försvara det gamla sakta men säkert går under.</p>
<p class="p4">* * *</p>
<p class="p4">I USA sjunker förtroendet för ”gammelmedia” för varje tweet Elon Musk lägger ut. I Sverige är förtroendet för public service fortsatt högt bland väljare till vänster, men lägre och sjunkande bland högerväljare.<sup>23</sup> Samtidigt fortsätter de stora tidningarnas pappersupplagor att sjunka i samma takt som de tvingas meddela nedskärningar.<sup>24</sup></p>
<p class="p4">Betyder <i>såna</i> saker något?</p>
<p class="p4">Kanske inte på kort sikt. De stora mediebolagen sitter på stora krigskassor. De kommer knappast att gå i graven i morgon, kanske inte ens i nästa vecka, men kurvan pekar neråt. Eller spiralen om man så vill. Elisabeth Noelle-Neumans ”tystnadsspiral”, som är applicerbar även på media.</p>
<p class="p4">Eller kanske <i>speciellt </i>på media.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="164395">  <span class="button-inner-wrapper">    <span class="left-part">      <i class="ti-arrow-circle-down"></i>    </span>    <span class="right-part">      <span class="default-text">Se noter</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="references">
<h3 id="noter" class="ref-heading" style="color: #000;;">Noter</h3>
<ol>
<li>https://www.foxnews.com/media/washington-posts-daily-digital-reader-base-shrunk-during-biden-years-nearly-90-internal-data-reveals</li>
<li>https://deadline.com/2024/12/cable-news-ratings-2024-fox-news-cnn-msnbc-1236243730/</li>
<li>https://www.expressen.se/ledare/ann-charlotte-marteus/det-ar-jag-som-ar-asiktskorridoren/</li>
<li>https://x.com/Vanstrastranden/status/602517460374450176</li>
<li>https://www.aftonbladet.se/kultur/a/kwdxjQ/kjell-haglund-om-malin-ekman</li>
<li>https://arbetet.se/2024/09/13/handelsbankens-youtubekanal-efn-tror-att-invandrare-ater-husdjur/</li>
<li>https://www.journalisten.se/nyheter/hellre-dalig-stamning-an-god-nar-alla-bara-spelar/</li>
<li>https://edition.cnn.com/2016/08/03/politics/mike-pence-donald-trump-apologist-in-chief/index.html</li>
<li>https://www.projectveritas.com/news/watch-cnn-technical-director-charlie-chester-remains-silent-on-current</li>
<li>https://abcnews4.com/amp/news/nation-world/project-veritas-says-it-caught-cnn-staffer-admitting-network-pushed-anti-trump-propaganda</li>
<li>https://www.svt.se/kultur/sant-och-falskt-i-janouch-debatten</li>
<li>https://www.aftonbladet.se/nyheter/samhalle/a/jewoL/kritik-mot-lofvens-janouch-uttalande</li>
<li>https://www.dn.se/kultur/martin-gelin-trumps-anhangare-har-angripit-mig-fysiskt/</li>
<li>https://portal.research.lu.se/sv/activities/after-mexico-sweden-experiences-the-most-explosive-attacks-in-the-3</li>
<li>https://www.svt.se/nyheter/lokalt/vastmanland/sa-gar-det-till-nar-en-analfabet-lar-sig-lasa</li>
<li>https://www.aftonbladet.se/nyheter/kolumnister/a/RzlmRJ/henrik-jonsson-hos-anders-holmberg-i-svt-visade-donald-trumps-metod</li>
<li>https://www.svtplay.se/video/8q1VXgB/svenska-scoop/2-nazistbilderna</li>
<li>https://www.svt.se/opinion/invandringen-har-gett-sverige-en-nettovinst-som-inte-kan-overskattas</li>
<li>https://www.friatider.se/dn-lj-g-om-rasism-p-brandstation-i-boden</li>
<li>https://www.svt.se/nyheter/granskning/ug/jag-trodde-pa-journalistiken</li>
<li>https://www.svt.se/nyheter/inrikes/wallstrom-inte-fortjust-i-jordan-b-peterson</li>
<li>https://www.svt.se/nyheter/lokalt/vastmanland/centerpartist-polisanmaldes-for-sexchatt-med-minderariga-utredningen-ar-nedlagd</li>
<li>https://www.norran.se/kronika/arvidsjaur/artikel/det-ar-aldrig-ok-att-gubbar-kontaktar-smatjejer-for-att-fa-sex/r4z8xk9l</li>
<li>https://omoss.svt.se/arkiv/bloggarkiv/2024-03-21-fortsatt-hogt-och-stabilt-fortroende-for-svt.html</li>
<li>https://www.svt.se/kultur/350-personer-kan-sparkas-fran-mediehuset-schibsted</li>
</ol>
</div>
</div>
<div class="author-byline"><strong>Jens Ganman</strong> är musiker och författare. Hans senaste böcker är &#8221;Det lilla landet som kunde&#8221; (2018), skriven tillsammans med <strong>Mustafa Panshiri</strong>, och romanen&nbsp;&#8221;De som kommer för att ta dig&#8221; (2017).&nbsp;
</div>
</div>
