Kulturkanon för en
prideparad med stridsvagn

<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%2Fkulturkanon-for-en-prideparad-med-stridsvagn%2F&amp;t=Kulturkanon+f%C3%B6r+en%3Cbr%3Eprideparad+med+stridsvagn"    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=Kulturkanon+f%C3%B6r+en%3Cbr%3Eprideparad+med+stridsvagn+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkulturkanon-for-en-prideparad-med-stridsvagn%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%2Fkulturkanon-for-en-prideparad-med-stridsvagn%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kulturkanon för en<br>prideparad med stridsvagn&body=https://kvartal.se/artiklar/kulturkanon-for-en-prideparad-med-stridsvagn/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/185695/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> | 29 augusti 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%2Fkulturkanon-for-en-prideparad-med-stridsvagn%2F&amp;t=Kulturkanon+f%C3%B6r+en%3Cbr%3Eprideparad+med+stridsvagn"    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=Kulturkanon+f%C3%B6r+en%3Cbr%3Eprideparad+med+stridsvagn+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fkulturkanon-for-en-prideparad-med-stridsvagn%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%2Fkulturkanon-for-en-prideparad-med-stridsvagn%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Kulturkanon för en<br>prideparad med stridsvagn&body=https://kvartal.se/artiklar/kulturkanon-for-en-prideparad-med-stridsvagn/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/185695/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 7 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/a746a3c1-3d76-4e4b-a725-db181dcdc208"    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-185695">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "185695"></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 ">Nästa vecka, den 2 september, kommer kulturkanonen att presenteras på en pressträff, och mottagandet från landets stora kultursidor lär bli livligt, som det heter.</p>
</div>
<div class="rest-of-article ">
<p>Kan vi räkna med att 1930-talets Tyskland är tillbaka? Och någon varnande liknelse med <strong>Trumps</strong> USA? När kulturminister <strong>Parisa Liljestrand</strong> presenterade kulturkanonen som färsk kulturminister 2022 sade hon att hon hoppades att den skulle bli en enande kraft.<sup>1</sup> Det blev den, med besked. Sveriges kulturelit slöt leden likt <strong>Karl XII</strong>:s karoliner mot detta verktyg för ”nationalistisk disciplinering” som DN Kulturs <strong>Kristina Lindquist</strong> uttryckte det. Författarförbundets upprop – undertecknat av något som skulle kunna vara en VIP-lista från Bokmässan i Göteborg – anklagade Kulturkanonen för att vara ett försök till statlig styrning av folks ord och tankar.<sup>2<span style="font-size: 16px;">, </span></sup><sup>3</sup> Och det var innan <strong>Lars Trägårdhs</strong> kommitté ens haft sitt första möte.</p>
<h2>Är det en avancerad trollning?</h2>
<p>Själv har jag tidigare i Kvartal skrivit att Parisa Liljestrand mest verkar använda kanonen för att trolla både högern och vänstern och i övrigt inte göra särskilt mycket – vilket även gäller för hennes portföljområden demokrati och mänskliga rättigheter.<sup>4</sup></p>
<p>Kulturkanonen var det enda konkreta kulturpolitiska målet i Tidöavtalet. I övrigt nämns att principen om armlängds avstånd ska upprätthållas. Det är naturligtvis bra. Jämför med USA, där president <strong>Donald Trump</strong> ägnar sig åt historieförfalskning och dikterar ideologi och innehåll på USA:s kulturinstitutioner som en andra klassens diktator.<sup>5</sup> Men samtidigt kan man konstatera att en svensk kulturminister <em>har</em> utnämningsmakt. Parisa Liljestrand har rätt att tillsätta cheferna i den statliga kulturflottan. Flaggskeppet är Kulturrådet, som sköt ut 2,6 miljarder kronor i bidrag till Kultursverige 2024. Generaldirektören för myndigheten, <strong>Kajsa Ravin</strong>, fick sitt jobb under miljöpartisten <strong>Amanda Linds</strong> tid som kulturminister.</p>
<p>Ravin är fortfarande chef på Kulturrådet och kommer att vara det tills hennes förordnande går ut 2026. Just nu pågår rekrytering av hennes efterträdare. I regeringens jobbannons<sup>6</sup> står de ideologiska önskemålen uttryckta: Kulturrådet ska integrera ett jämställd­hets-, mångfalds- och barn- och ungdomsperspektiv inom kulturområdet. ”Kunskap om krisberedskapsfrågor och totalförsvar är meriterande.”</p>
<p>Hade inte det lika gärna kunnat vara en jobbannons från en <strong>Magdalena Andersson</strong>-regering?</p>
<p>Annonsen nämner inte konstnärlig frihet, vilket är synd i dessa tider då yttrandefriheten är hotad från alla håll. I stället hänvisar den till att Kulturrådet utgår från de nationella kulturpolitiska målen. Men totalförsvarets intressen går inte nödvändigtvis ihop med målet att kulturen ska vara en ”dynamisk utmanande kraft”. En skygglapp är en skygglapp, även om den är kamouflagemålad. Eller regnbågsfärgad.</p>
<blockquote><p>Sverige 2025 är en prideparad med stridsvagnar.</p></blockquote>
<p>Kulturrådet är en av regeringens 13 hbtqi-strategiska myndigheter, som ska integrera det perspektivet i verksamheten. Det är inget tvivel om vilka intresseorganisationer som får sätta agenda. Arbetet sker i samarbete med RFSL, RFSL Ungdom och föreningen för transpersoner FPES, skriver Kulturrådet på sin sajt.<sup>7</sup></p>
<p>Som exempel på hbtqi-verksamhet som Kulturrådet stöttar nämns sagostunden <em>Bland drakar och dragqueens</em>, som har väckt motsatsen till entusiasm bland konservativt sinnade.</p>
<p>Alltså: Totalförsvar med hbtqi-perspektiv. Sverige 2025 är en prideparad med stridsvagnar.<sup>8</sup></p>
<p>Någon abrupt omläggning är det inte frågan om.</p>
<p>Under Parisa Liljestrands tid har regeringen valt att ge förlängd anställning till fem myndighetschefer som anställdes under den rödgröna regeringstiden. Det visar research som Kvartals praktikant <strong>Adam Bokinge</strong> gjorde tidigare i år.<sup>9</sup></p>
<p>Parisa Liljestrand har gett <strong>Martin Sundin</strong> förlängt som generaldirektör för Institutet för språk och folkminnen. Sundin har utsett <strong>Lena Lind Palicki</strong> till chef för Språkrådet. Där råder en typiskt språkliberal låt-gå-doktrin mot den stötiga, grammatiskt felaktiga och ordfattiga förortssvenskans framryckning (för mer om kreolsvenskan, se artikelserien <a href="https://kvartal.se/artiklar/hotet-mot-det-svenska-spraket/"><em>Hotet mot det svenska språket</em></a> och Palickis egen artikel <a href="https://kvartal.se/artiklar/sprakradet-inget-problem-att-svenskan-forandras/"><em>Inget problem att språket förändras</em></a>).</p>
<p><strong>Lars Amréus</strong> fick förlängt som överintendent för Statens maritima och transporthistoriska museer, SMTM, som Vasamuseet är en del av. Han var chef för Riksantikvarieämbetet under <strong>Alice Bah Kuhnke</strong>, en myndighet som bland annat jag kritiserade för politisk aktivism under museidebatten om politisk styrning av kulturen.<sup>10</sup></p>
<p>Världskulturmuseet har fått en ny chef, <strong>Britta Söderqvist</strong>, men museet fortsätter sitt oförtröttliga arbete med att kritisera de egna samlingarna i någon form av självhatande reningsritualer. Nu har de projektet <em>Att väcka föremålen till liv – och utmana museernas koloniala historier.</em><sup>11</sup></p>
<h2>Signalpolitik från ett sjunkande skepp</h2>
<p>Det är naturligtvis inget fel i sig med kontinuitet. Det är bra att sakkunskap belönas. Parisa Liljestrands regering utsåg 2023 <strong>Patrick Amsellem</strong> till chef för Nationalmuseum. Denne har blivit någon form av intellektuell kändis genom medverkan som konstexpert i SVT:s <em>Kontrapunkt</em>. Han har tidigare varit generaldirektör för Statens konstråd och innan dess jobbat för Skissernas museum och Brooklyn museum i New York. Direkt i samband med att hans utnämning meddelade han att <strong>Rembrandts</strong> målning <em>Batavernas trohetsed</em> blir kvar på Nationalmuseum, det usla ekonomiska läget till trots. Bra så!</p>
<p>Men regeringen har snarare bidragit till att cementera krisen. Planen är att utöka systemet med marknadshyror till att även gälla Operan, Nationalmuseum och andra statliga kulturinstitutioner som hittills varit undantagna.</p>
<p>Det absurda systemet leder till att pengar flyttas runt i systemet, något som <strong>Lena Svanberg</strong> påtalade redan i sin ESO-rapport <em>Leka marknad</em> från år 2000. ”Det är av naturliga skäl svårt att avgöra vad som är en marknadshyra för ett museum som är specialbyggt för skeppet Vasa”, som Vasamuseets ekonomichef <strong>Johan Ericsson </strong>uttrycker det lite syrligt i ett mejl – men staten har satt den till 46 miljoner kronor.</p>
<p>Lösningen påstås nu vara att staten anpassar anslagen till Statens fastighetsverks ”marknadshyror”. Tänk att ingen tänkt på det förut – det är ju bara att höja anslagen! Men hur realistiskt är det när ockerhyrorna redan i nuläget tränger ut verksamhet.</p>
<p>Kulturkanonens syfte är att vara verktyg för bildning (jag har lite svårt att förstå upprördheten över det). Men en kulturpolitik för <em>bildning</em> och <em>kulturarv</em> handlar i grunden om att vårda institutionerna för dessa, och att tillsätta chefer som är kunniga om och lojala mot det som står på skylten. I Östasiatiska museets fall skulle det innebära Östasiens kulturhistoria!</p>
<blockquote><p>Hon har varit försiktig med att använda sin utnämningsmakt.</p></blockquote>
<p>Det innebär också att man aktar sig för <em>new public management</em>-tänkande och lär sig av tidigare regeringars övertro på centralisering. När Östasiatiska, Etnografiska och Medelhavsmuseet slogs samman med Världskulturmuseet blev resultatet ”en kulturell ruin”, varnade Konstakademien tidigare i år och menar att något liknande riskerar att upprepas när regeringen nu låter Moderna Museet svälja ArkDes och Statens Konstråd.<sup>12</sup></p>
<p>Vasa håller på att brytas ned av sin egen tyngd och är i behov av stöttning. Det kostar drygt 200 miljoner. I nuläget saknas 175 av dem, pengar som museet kommer att behöva låna.<sup>13</sup></p>
<p>”Svensk kulturpolitik har blivit ren signalpolitik utan substans”, skriver <strong>Anna Troberg</strong>, förbundsordförande för DIK, facket för Kultur, kommunikation och kreativ sektor, på Linkedin. Nå, vi får väl se vad kommittén kommer fram till på tisdag.</p>
<p>Kulturkanonen är onekligen galjonsfiguren för Tidöregeringens kulturpolitik.</p>
<p>Men man kan konstatera att med ett år till valet så har kulturministern inte gjort någon omläggning av kulturskeppet Sveriges kurs. Hon har varit försiktig med att använda sin utnämningsmakt, en del skulle kanske säga för försiktig.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="185695">  <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><a href="https://www.svt.se/kultur/kulturministern-om-kulturkanon-ska-ena-ett-splittrat-sverige"><em>Nya kulturministern Parisa Liljestrand (M): ”Kulturkanon kan vara en enande kraft”</em></a> (SVT Nyheter, 25 oktober 2022)</li>
<li><a href="https://forfattarforbundet.se/upprop-mot-en-av-staten-bestamd-litterar-kanon/"><em>Upprop mot en av staten utfärdad litterär kanon</em></a> (Sveriges Författarförbund, 16 november 2022)</li>
<li>Det är sällan Svenska Akademiens <strong>Mats Malm</strong> och <strong>Camilla Läckberg</strong> är ute på samma sida i samma debatt – men det här var ett sådant tillfälle. <em><a href="https://www.dn.se/kultur/mats-malm-svenska-akademien-kommer-inte-att-bidra-till-att-skapa-en-kanon/">Mats Malm: ”Svenska Akademien kommer inte att bidra till att skapa en kanon”</a></em> (Dagens Nyheter, 9 december 2022)</li>
<li><a href="https://kvartal.se/artiklar/alla-dessa-forbjudna-ord/"><em>Alla dessa förbjudna ord</em></a> (Ola Wong, Kvartal, 4 maj 2024)</li>
<li><em><a href="https://kvartal.se/artiklar/nar-presidenten-styr-kulturen/">När presidenten styr kulturen</a></em> (Karin Henriksson, Kvartal, 11 juni 2025)</li>
<li><a href="https://arbetsformedlingen.se/platsbanken/annonser/29932440">https://arbetsformedlingen.se/platsbanken/annonser/29932440</a></li>
<li><a href="https://www.kulturradet.se/i-fokus/hbtqi/vart-uppdrag/">https://www.kulturradet.se/i-fokus/hbtqi/vart-uppdrag/</a></li>
<li><a href="https://www.regeringen.se/pressmeddelanden/2024/08/uppdrag-om-att-starka-kunskapen-om-hbtqi-personers-rattigheter-och-mojligheter/">https://www.regeringen.se/pressmeddelanden/2024/08/uppdrag-om-att-starka-kunskapen-om-hbtqi-personers-rattigheter-och-mojligheter/</a></li>
<li>Följande myndighetschefer under Kulturdepartementet har anställts av den förra regeringen (3/10 2014 – 18/10 2022) och fått förlängd anställning av nuvarande regering, enligt mejl från Kulturdepartementets rättssekretariat den 20 februari: 1, <strong>Martin Sundin</strong>, Institutet för språk och folkminnen, 2, <strong>Magnus Larsson</strong>, Myndigheten för tillgängliga medier, 3. <strong>Karin Iko Åström</strong>, Riksarkivet, 4, <strong>Lars Amréus</strong>, Statens maritima och transporthistoriska muséer, 5, <strong>Dan Lundberg</strong>, Statens musikverk.</li>
<li><a href="https://www.svd.se/a/RkMLx/museichefer-utan-kunskap-forodande-for-kulturarvet"><em>Museichefer utan kunskap – förödande för kulturarvet</em></a> (Ola Wong, Svenska Dagbladet, 26 september 2017)</li>
<li><a href="https://www.varldskulturmuseerna.se/projekt/att-vacka-foremalen-till-liv/">https://www.varldskulturmuseerna.se/projekt/att-vacka-foremalen-till-liv/</a></li>
<li><a href="https://www.regeringen.se/regeringsuppdrag/2025/05/uppdrag-till-moderna-museet-att-forbereda-inordnandet-av-statens-centrum-for-arkitektur-och-designs-och-statens-konstrads-uppgifter-i-myndigheten/">https://www.regeringen.se/regeringsuppdrag/2025/05/uppdrag-till-moderna-museet-att-forbereda-inordnandet-av-statens-centrum-for-arkitektur-och-designs-och-statens-konstrads-uppgifter-i-myndigheten/</a></li>
<li>Källa är Peter Rydebjörk, projektchef för Stötta Vasa. <a href="https://www.vasamuseet.se/om-vasamuseet/stotta-vasa">https://www.vasamuseet.se/om-vasamuseet/stotta-vasa </a></li>
</ol>
<p>&nbsp;</p>
</div>
</div>
<div class="author-byline">Ola Wong är Kvartals kulturredaktör, Kina-kännare och författare.
</div>
</div>
