Kriget om public service

<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%2Fkriget-om-public-service%2F&amp;t=Kriget+om+public+service"    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=Kriget+om+public+service+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-public-service%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%2Fkriget-om-public-service%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kriget om public service&body=https://kvartal.se/artiklar/kriget-om-public-service/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/181630/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/2024/07/Ola_lowres2.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2024/07/Ola_lowres2.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/ola-wong/">Ola&nbsp;Wong</a> | 2 juli 2025<div class="author-desc">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</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%2Fkriget-om-public-service%2F&amp;t=Kriget+om+public+service"    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=Kriget+om+public+service+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkriget-om-public-service%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%2Fkriget-om-public-service%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kriget om public service&body=https://kvartal.se/artiklar/kriget-om-public-service/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/181630/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 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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/fc5a55c3-ac76-429d-99e4-12c79d3ea1ca"    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-181630">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "181630"></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 "><em>TV Republika</em> är Polens svar på <em>Fox News</em> i USA, ett hem för det fria ordet, som <strong>Adrian Stankowski</strong> kallar det när jag möter honom på redaktionen i huvudstaden Warszawa<span style="color: #ff0000;"><span style="color: #000000;">.</span></span> Stankowski är politisk journalist och ett av kanalens kända ansikten. Presidentvalet i Polen tidigare i år var en stor framgång för <em>TV Republika</em>; dels vann kandidaten <strong>Karol Nawrocki</strong>, som är uppbackad av nationalkonservativa Lag och rättvisa (PiS), dels så fick deras sändningar ett stort genomslag. <em>TV Republika</em>-profilen <strong>Michal Rachon</strong> har som ende polske journalist fått en egen intervju med <strong>Donald Trump</strong>. Kanalen presenterar sig nu som den största och viktigaste konservativa tv-stationen i Europa. Orsaken till <em>TV Republikas</em> framgång kan paradoxalt nog spåras till regeringens försök att avpolitisera public service.</p>
</div>
<div class="rest-of-article ">
<h2>Sändningsstopp på grund av bristande opartiskhet</h2>
<p>När den liberalkonservativa <strong>Donald Tusks</strong> koalition vann parlamentsvalet 2023, skedde det med löften om återställare för den liberala demokratin efter åtta år av styre från Lag och rättvisa, som bland annat hade omvandlat public service till en propagandakanal för partiet.</p>
<p>Tilliten för public service hade då sjunkit kraftigt, polariseringen i samhället förvärrades och till slut uppgav bara 29 procent av de svarande i en undersökning att de hade förtroende för <em>TVP</em>, som är Polens svar på SVT.<sup>1</sup></p>
<figure id="attachment_181634" aria-describedby="caption-attachment-181634" style="width: 1202px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-181634 size-full" src="https://kvartal.se/wp-content/uploads/2025/07/Pasted-Graphic.jpeg" alt="" width="1202" height="1412" data-wp-pid="181634" srcset="https://kvartal.se/wp-content/uploads/2025/07/Pasted-Graphic.jpeg 1202w, https://kvartal.se/wp-content/uploads/2025/07/Pasted-Graphic-255x300.jpeg 255w, https://kvartal.se/wp-content/uploads/2025/07/Pasted-Graphic-768x902.jpeg 768w, https://kvartal.se/wp-content/uploads/2025/07/Pasted-Graphic-600x705.jpeg 600w" sizes="(max-width: 1202px) 100vw, 1202px" /><figcaption id="caption-attachment-181634" class="wp-caption-text"><em>Public service anklagades för att sprida hatpropaganda under PiS-tiden, ibland bokstavligen demoniserades oppositionsledaren Donald Tusk av tv-nyheterna, som här. Skärmdump: TVP</em></figcaption></figure>
<p>Så den 20 december 2023 slocknade rutan för miljoner av polacker. I stället för kvällsnyheterna från <em>TVP</em>, polsk public service, kom budskapet: ”Sändningsstopp”. Den nya regeringen hade slagit till. PiS-trogna chefer och styrelserna för public servicebolagen och den polska nyhetsbyrån byttes ut. Några av dem försökte panikartat ockupera högkvarteret för public service. Även människorättsgrupper kritiserade beslutet, som ansågs stå på en svag juridisk grund.<sup>2</sup> Men resultatet blev att en mängd gamla chefer och journalister som sagt upp sig eller fått sparken under PiS-tiden nu återvände till public service. I andra riktningen gick utpekade propagandajournalister och redaktörer – ut från public service och in till <em>TV Republika</em>. Från att ha varit en nischkanal blev <em>TV Republika</em> nästan över en natt en av Polens viktigaste medieaktörer. Deras bevakning av dramatiken i det statliga tv-huset i slutet av december 2023 blev de mest sedda nyhetssändningarna i landet.</p>
<p>Adrian Stankowski har idag blandade känslor inför det som skedde under PiS-tiden.</p>
<p>– Det är sant att PiS förvandlade statliga tv-tjänster till ett åsiktsrör. Jag har själv kritiserat PiS för att de gjorde så, det hade varit bättre om de satsat på <em>TV Republika</em> i stället. Men när man tittar på det i ett bredare sammanhang måste man tänka på att 80 procent av medierna i Polen är vänsterinriktade och sprider propaganda och lögner varje dag. Så jag tror det krävdes någon form av balans, men sättet den balansen infördes på kan man ifrågasätta, säger han.</p>
<p>Han ger inte mycket för regeringens politik om att ”avpolitisera medierna”.</p>
<p>– Medier är politiska i hela världen. Om man låtsas vara objektiv så ljuger man. <em>Fox</em> och <em>CNN</em> i USA är också politiska.</p>
<figure id="attachment_181642" aria-describedby="caption-attachment-181642" style="width: 1015px" class="wp-caption alignnone"><img decoding="async" class="wp-image-181642 size-full" src="https://kvartal.se/wp-content/uploads/2025/07/Michal-Rachon-moter-Trump.jpg" alt="" width="1015" height="564" data-wp-pid="181642" srcset="https://kvartal.se/wp-content/uploads/2025/07/Michal-Rachon-moter-Trump.jpg 1015w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Rachon-moter-Trump-300x167.jpg 300w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Rachon-moter-Trump-768x427.jpg 768w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Rachon-moter-Trump-600x333.jpg 600w" sizes="(max-width: 1015px) 100vw, 1015px" /><figcaption id="caption-attachment-181642" class="wp-caption-text"><em>TV Republikas journalist fick en exklusiv intervju med Donald Trump. Skärmdump: Youtube</em></figcaption></figure>
<p>Han menar att problemet är att de som sitter i regering nu i Polen anser att högerinriktade åsikter är sämre och därför borde inte de få spridas.</p>
<p>– Man måste inse att hälften eller fler av polackerna har högeråsikter och de har rätt till egna medier.</p>
<p>Vad gäller anklagelserna om propaganda och demonisering av Tusk så menar han att Tusk förtjänar det.</p>
<p>– Problemet är att makthavarna inte är vana vid att bli kritiserade, de känner sig obekväma för att vi ställer nya typer av frågor. Men det är yttrandefrihet!</p>
<p>Han menar att <em>TV Republika</em> är utsatt för ett smutsigt spel, där dolda krafter inom säkerhetstjänsten motarbetade dem och att de utsätts för en statligt orkestrerad bojkott.</p>
<p>– Situationen kan liknas vid hur judiska affärer drabbades under nazisttiden, säger han.</p>
<p>En drastisk jämförelse med tanke på ödet för Polens judar. Det är överhuvudtaget en känsla av <em>Alice i Underlandet</em> över vissa av de teorier han framför med stor självsäkerhet och övertygande röst. Exempelvis analysen att Tyskland försöker driva USA ut ur Europa för att kunna bygga ett nytt Fjärde rike i samarbete med Ryssland. För de flesta är det uppenbart att Tyskland chockades av Trumps hot om att överge Nato och Europa. Men inte på <em>TV Republika</em>.</p>
<p>– Det finns nu ett tyskt försök att bygga det så kallade Fjärde riket – EU blir ett land och Polen förlorar sin självständighet. Att tvinga ut USA:s styrkor ur Europa ligger i Tysklands intresse för då får Tyskland hegemoni över EU.</p>
<p>Det låter bisarrt och bevis saknas förvisso. Men om en stor del av tittarna nu vill höra sådana budskap – borde de inte få det? Eller?</p>
<h2>När extremism blir normalt</h2>
<p><strong>Agata Szczęśniak</strong> är journalist på det lilla mediehuset <em>OKO press</em>. Det startade som en faktagranskande reaktion på fenomenet att ”politiker började ljuga om allt”.</p>
<p>– Jag kan köpa argumentet att <em>TV Republika</em> inte låtsas vara balanserade. De vill skapa det största konservativa mediehuset i Europa, men det kan bli svårt med polskan, säger hon med ett snett leende.</p>
<p>Hon pekar på problemet med normalisering av extrema åsikter. Som när högerextrema gäster likt <strong>Marian Kowalski</strong> får plats i tv-soffan och tillåts sprida konspirationsteorier om judiska sammansvärjningar mot polacker. <em>TV Republika</em> lyckas också avväpna traditionella mediers granskningar.</p>
<blockquote><p><em>TVP</em> är tyvärr fortfarande propaganda, inte så illa som på Kurskis tid, men de är definitivt på Tusks sida.</p></blockquote>
<p>Under valkampanjen rapporterade traditionella medier flera skandaler om den PiS-uppbackade kandidaten Karol Nawrocki. Särskilt en nyhet, om att Nawrocki skulle ha lurat till sig en lägenhet av en äldre man i Gdansk, hade potential att allvarligt skada kampanjen. Men <em>TV Republikas</em> kommentariat lyckades vända berättelsen till att handla om medierna och den djupa staten.</p>
<p>– På kampanjmötena upprepade Nawrocki-anhängarna argumenten som de hört på <em>TV Republika</em>, metoden fungerar, konstaterar hon.</p>
<p>Nawrocki vann valet med ett hårsmån.</p>
<p>Hon berättar att public service alltid har varit partiska i Polen, men det gick på överväxel när en PiS-politiker, <strong>Jacek Kurski,</strong> fick ta över som chef för <em>TVP</em>. Han drog i gång en storsatsning på public service som fick en kraftigt ökad budget. Det ena benet bestod av lätt underhållning, sport- och realityprogram. Det andra var propaganda; budskapet var hela tiden att Tusk är ond, Tusk är en tysk agent, nyheterna sände bilder på Tusk med kikarsikte på sig eller så att det såg ut som om han hade djävulshorn och fulklippningar av Tuskcitat kördes gång på gång, särskilt ett där han sade orden ”<em>Für Deutschland”</em> (För Tyskland).<sup>3</sup></p>
<p><strong>Hur har det gått med regeringens mål att avpolitisera public service? </strong></p>
<p>– Förväntningarna var höga. Det kom massor av förslag från akademiker och experter hur det skulle kunna gå trovärdigt till, men man lyssnade inte så mycket på dem. <em>TVP</em> är tyvärr fortfarande propaganda, inte så illa som på Kurskis tid, men de är definitivt på Tusks sida.</p>
<p>I Polen ska nyhetsmedier vara opartiska. Det finns ett mäktigt sändningsråd, KRRiT, som övervakar medierna och kan bötfälla dem, men rådet är nu inne i ett ställningskrig med Tuskregeringen, som vill få bort dess ledare, den konservative aktivisten <strong>Maciej </strong><strong>Ś</strong><strong>wirski</strong>, som tillsattes under PiS-tiden.</p>
<p>Efter det kuppartade övertagandet av public service 2023 har sändningsrådet hållit inne medel som skulle ha gått till public service, med hänvisningen till ”juridiskt kaos”.</p>
<p>Świrski har även bötfällt medier som anses vara fientliga mot PiS agenda – bland annat fick 2024 den stora privata tv-kanalen <em>TVN</em> motsvarande över 1,4 miljoner kronor i böter efter att ha sänt en dokumentär om pedofilskandaler och påven <strong>Johannes Paulus II</strong>.</p>
<p>Tusks regering har svarat med att försöka få Świrski ställd inför Statsdomstolen, anklagad för politiskt motiverade beslut mot medierna (något han förnekar).</p>
<figure id="attachment_181643" aria-describedby="caption-attachment-181643" style="width: 2560px" class="wp-caption alignnone"><img decoding="async" class="wp-image-181643 size-full" src="https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-scaled.jpg" alt="" width="2560" height="1920" data-wp-pid="181643" srcset="https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-scaled.jpg 2560w, https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-300x225.jpg 300w, https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-768x576.jpg 768w, https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-1536x1152.jpg 1536w, https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-2048x1536.jpg 2048w, https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-scaled-1200x900-cropped.jpg 1200w, https://kvartal.se/wp-content/uploads/2025/07/Grzegorz-Sajor-nyhetschef-TCP-600x450.jpg 600w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-181643" class="wp-caption-text"><em>Grzegorz Sajór säger att han vill återuppbygga public service, nu är han nyhetschef på TVP. Foto: Ola Wong</em></figcaption></figure>
<h2>Public service konfronterar post-sanning</h2>
<p>– Vi väntar på att få en lag som kan skilja oss från politiken, säger nyhetschefen <strong>Grzegorz Sajór </strong>och vicedirektören <strong>Jan Ciszecki</strong>, som bägge jobbar för <em>TVP</em>:s centrala nyhetsredaktion.</p>
<p>De lär få vänta länge. Dödläget i polsk politik, mellan en liberal regering och en nationalkonservativ president som kan blockera lagar, gör reformer omöjliga. Om PiS vinner nästa parlamentsval 2027 räknar de med att public service kommer att återgå till att bli en propagandakanal igen, fast värre den här gången. Sajór sa upp sig under Kurskis tid som chef och återanställdes när PiS-cheferna störtades 2023.</p>
<blockquote><p>Om du säger att påståendet saknar bevis så blir du en del av konspirationen.</p></blockquote>
<p>Medan<em> TV Republikas</em> redaktion utstrålade självförtroende och framgång – med välsittande kostymer för herrarna och designerväskor för damerna – så känns stämningen betydligt mer jämngrått institutionsartad när vi möts i <em>TVP</em>:s lite slitna betongbyggnad i Warszawa.</p>
<p>– Jag har konfronterat många regeringar under mina 25 år här, och det är inget som kan jämföras med hur propagandan var under den tiden. Varje dag var det en hatkampanj mot någon ny grupp, ena dagen migranter, den andra läkare, domare, htbq-människor och så vidare. Många menar att det var värre än under kommunisttiden, säger Sajór.</p>
<p>Han säger att han återvände till public service från ett bra jobb inom den privata mediesektorn för att han ville bidra till att rädda institutionen. Men det är svårt att återställa förtroendet. Många tittare längtar efter den typ av nyheter som gavs under Kurskis tid, säger Jan Ciszeck. De vill ha ett väldigt TYDLIGT och väldigt ENKELT budskap. De tror inte på sanningen – om deras sida av politiken säger att något är sant så blir det sant. Bevis eller välunderbyggda argument spelar inte längre någon roll.</p>
<p>Som exempel nämner han ”nyheten” att EU kommer att tvinga polackerna att äta insekter. Det är väldigt svårt att motarbeta sådan desinformation. Om du säger att påståendet saknar bevis så blir du en del av konspirationen. Om du hänvisar till att EU säger något annat i verkligheten blir reaktionen:  &#8217;Ja, de skulle ju säga så&#8217;, säger Jan Ciszecki.</p>
<p><strong>Vad säger ni om anklagelsen om att ni partiska för Tusk och också sprider propaganda? </strong></p>
<p>– Vi försöker visa ett balanserat utbud. Vi är nog inte idealiska, men det är under alla omständigheter orättvist att jämföra oss med hur det var under Kurskis tid, säger Sajor.</p>
<p>Han understryker att chefen för <em>TVP</em> numera är en journalist, medan Kurski var en politiker.</p>
<p>– Kurski förstörde public service och vi försöker återuppbygga den, och det är inte lätt.</p>
<p>Åsiktsskillnader är något sunt i en demokrati, men när åsiktsskillnader övergår i en djup, oförsonlig splittring där folk börjar demonisera den andra sidan av politiken så råder polarisering. Enligt organisationen <em>Polski Dialog</em> är polariseringsindex i Polen till och med värre än i det starkt splittrade USA.<sup>4</sup></p>
<p><strong>Har public service en legitim framtid i ett land som är så splittrat och synen på verkligheten skiljer sig åt så dramatiskt? </strong><strong>Är det möjligt att göra ett opartiskt public service? </strong></p>
<p>– Den tiden är över. Även när vi försöker så kommer folk tycka att vi inte är objektiva, säger <strong>Michał Nogaś</strong>, en känd kulturjournalist och biträdande redaktör för den legendariska public service-radiokanalen <em>Radio Trojka</em>, som under kommunismen blev populär för att de spelade västlig musik.</p>
<figure id="attachment_181645" aria-describedby="caption-attachment-181645" style="width: 1920px" class="wp-caption alignnone"><img decoding="async" class="wp-image-181645 size-full" src="https://kvartal.se/wp-content/uploads/2025/07/Michal-Nogas-Radio-Trojka-kopia-scaled.jpg" alt="" width="1920" height="2560" data-wp-pid="181645" srcset="https://kvartal.se/wp-content/uploads/2025/07/Michal-Nogas-Radio-Trojka-kopia-scaled.jpg 1920w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Nogas-Radio-Trojka-kopia-225x300.jpg 225w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Nogas-Radio-Trojka-kopia-768x1024.jpg 768w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Nogas-Radio-Trojka-kopia-1152x1536.jpg 1152w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Nogas-Radio-Trojka-kopia-1536x2048.jpg 1536w, https://kvartal.se/wp-content/uploads/2025/07/Michal-Nogas-Radio-Trojka-kopia-600x800.jpg 600w" sizes="(max-width: 1920px) 100vw, 1920px" /><figcaption id="caption-attachment-181645" class="wp-caption-text"><em><span class="s1">”För oss är det viktigt att få folk att öppna sina sinnen och tänka själv”, säger Michał Nogaś</span> på Radio Trojka. Foto: Ola Wong</em></figcaption></figure>
<p>– Folk är förgiftade av lögner från bägge sidor i politiken, det gör det väldigt svårt att vinna tillit. Man har hela tiden sociala medier i bakhuvudet och alternativa budskap som mässar om att vi saknar legitimitet och sänder propaganda. De flesta länder kommer att möta det problemet för vi lever i en era av populism. USA är det bästa exemplet, säger Nogaś.</p>
<p>– Kommunismen gjorde att det är lätt att manipulera folk i det här landet. Och eftersom världen skakar nu så bryr sig folk inte om politiker säger sanningen eller inte, de vill bara att politikerna säger vad de vill höra. Jag tycker en journalist ska försöka visa hur världen fungerar och inte ljuga. Men många journalister ser det som sin uppgift att stötta en eller annan politiker och har inga problem med att dölja sanningen.</p>
<p>Michał Nogaś sa upp sig under <em>PiS</em>-tiden när han märkte hur ledningen försökte detaljstyra hans arbete och vilka författare som skulle uppmärksammas. Under pandemin demonstrerade människor utanför redaktionen i protest mot att en sång som i förtäckta ordalag kritiserade presidenten hade censurerats.<sup>5</sup></p>
<p>– Under kommunismen skrev folk på väggarna att tv ljuger, och så skedde också under <em>PiS</em>, berättar Nogaś.</p>
<p>–  Vi har några som fick mentala problem eller blev inlagda för de stod inte ut med vad som hände med public service. Vi återuppbygger det, men det kan när som helst förstöras igen.</p>
<h2>En glimt av framtiden?</h2>
<p>Det mest slående intrycket för mig med Polen och public service är hur tron på sanningen rivits ner, och hur svårt det är att korrigera institutioner som har övergivit kärnvärderingar om objektivitet och politiskt oberoende. Ett hyckleri är trots allt att föredra framför naken cynism. Motåtgärder riskerar att mötas av anklagelser om politisering åt andra hållet, medan avsaknad av reformer förvärrar problemen. Under tiden växer misstron och motviljan mot de kompromisser som demokratin bygger på, en tendens som blir tydligare i ett land som av historiska skäl är splittrat och har låg tillit till politiken.</p>
<p>När en postmodern sanningsrelativism tar över blir ingenting sant och allting möjligt, som <strong>Peter Pomerantsev</strong> beskrev etoset i Putins medievärld. Det driver fram en längtan efter auktoritära lösningar för att upprätta ett nytt sanningsparadigm.</p>
<p>Men jag åker också därifrån med en känsla av att ha sett en föraning om vad som kan bli mediernas och public services framtid även i Sverige. Den kanske största vinnaren i presidentvalet var det unga politiska stjärnskottet, Maga-högernationalisten <strong>Sławomir Mentzen</strong>, som oväntat kom trea. Han kommunicerar med sina väljare på Tiktok och Youtube. Under valkampanjen blev det ett återkommande inslag att Mentzen avslutade sina möten genom att strunta i journalisternas frågor och åka i väg på en elsparkcykel.</p>
<p><em>(Artikeln är baserad på intervjuer gjorda i Warszawa 18–21 maj.)</em></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="181630">  <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://reutersinstitute.politics.ox.ac.uk/digital-news-report/2024/poland</li>
<li>Se: <a href="https://verfassungsblog.de/protecting-polands-public-media/"><em>Protecting Poland’s public media</em></a> (Verfassungsblog, 20 december 2024)<br />
<em>The Helsinki Foundation for Human Rights </em>noterade att metoderna liknade de som PiS använt för att ta över medierna och även om det fanns ett akut reformbehov så väckte tillvägagångssättet starka invändningar. Se: <a href="https://www.bbc.com/news/world-europe-67929549"><em>Polish police arrest politicians in presidential palace</em></a> (BBC News, 10 januari 2024)</li>
<li>Se även: https://tvn24.pl/polska/tvp-przeprasza-donalda-tuska-za-czerwona-poswiate-celownik-i-fur-deutschland-st8022106</li>
<li>https://polskidialog.pl/post_wiedza/o-co-chodzi-z-tymi-podzialami/</li>
<li><a href="https://www.bbc.com/news/world-europe-52721152"><em>Polish hit song on grieving &#8217;censored&#8217;, sparking protests</em></a> (BBC News, 19 maj 2020)</li>
</ol>
</div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
