Så lämnade Melonis parti antisemitismen

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/anders-carlberg/">Anders&nbsp;Carlberg</a> | 2 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%2Fsa-lamnade-melonis-parti-antisemitismen%2F&amp;t=S%C3%A5+l%C3%A4mnade+Melonis+parti+antisemitismen"    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=S%C3%A5+l%C3%A4mnade+Melonis+parti+antisemitismen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-lamnade-melonis-parti-antisemitismen%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%2Fsa-lamnade-melonis-parti-antisemitismen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så lämnade Melonis parti antisemitismen&body=https://kvartal.se/artiklar/sa-lamnade-melonis-parti-antisemitismen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/160214/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%2Fsa-lamnade-melonis-parti-antisemitismen%2F&amp;t=S%C3%A5+l%C3%A4mnade+Melonis+parti+antisemitismen"    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=S%C3%A5+l%C3%A4mnade+Melonis+parti+antisemitismen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-lamnade-melonis-parti-antisemitismen%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%2Fsa-lamnade-melonis-parti-antisemitismen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så lämnade Melonis parti antisemitismen&body=https://kvartal.se/artiklar/sa-lamnade-melonis-parti-antisemitismen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/160214/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 10 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/160214"    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-160214">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "160214"></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 ">Den person som kom att dominera den nyfascistiska rörelsen i efterkrigstidens Italien var <strong>Giorgio Almirante</strong>. Under Mussoliniåren hade han verkat som redaktionssekreterare på tidningen <em>La Difesa della Razza</em> (”Försvaret för Rasen”). I Salòrepubliken under krigets två sista år tjänstgjorde han som hög tjänsteman på kulturministeriet.</p>
</div>
<div class="rest-of-article ">
<p>Eftersom han vid krigsslutet med rätta sågs som en Mussolinianhängare fann Almirante ingen annan råd än att gå under jorden. Ett politiskt beslut kom dock att förändra förutsättningarna för hans tillvaro och öppnade för en förnyad politisk karriär.</p>
<p>En amnesti utfärdades sommaren 1946, och den var resultatet av en kompromiss mellan det italienska kommunistpartiet och de starka kristdemokraterna. Med amnestin benådades åtskilliga fascister och partisaner, och många redan utdömda fängelsestraff reducerades. Fascister som Almirante kunde därmed komma fram från sina gömställen.</p>
<h2>Den nyfascistiska rörelsen</h2>
<p>Almirante hörde sedan till den grupp som på annandag jul 1946 bildade det nyfascistiska partiet <em>Movimento Sociale Italiano</em>, MSI. Fram till sin död 1988 utgjorde Almirante kontinuiteten i MSI; han tjänade av och till som partiledare och var parlamentsledamot i många år.</p>
<p>Partiet hade en nyfascistisk identitet, men var ”demokratiskt av nödvändighet”.<sup>1</sup> Egentligen hade den italienska konstitutionen förbjudit ”återbildandet av fascistpartiet”. Detta blev italiensk lag 1952 och då förbjöds uttryckligen partier som är motståndare till det demokratiska systemet. Men lagen var samtidigt konstruerad på ett sådant sätt att den inte skulle ifrågasätta MSI:s legitimitet.</p>
<p>Det nyfascistiska partiet MSI balanserade mellan att å ena sidan framhålla <strong>Mussolinis</strong> ”oförstörbara lära” och å andra sidan hålla en distans och visa att man som parti utgjorde något nytt. I ett försök att agera i denna anda skrev Almirante 1958: ”Vi förbinder oss att inte på ett mekaniskt och okritiskt sätt höja allt fascistiskt till skyarna och motsätta oss all form av anti-fascism.”<sup>2</sup></p>
<p>Inledningsvis utmärktes partiets program av ett motstånd mot såväl sovjetisk-marxistisk materialism som amerikansk kapitalism. I utrikespolitiken var målet att segrarmakterna i andra världskriget – Sovjet, Storbritannien och USA – skulle hållas borta från inflytande i Italiens intressesfär, det vill säga Medelhavet.<sup>3</sup></p>
<h2>På Egyptens sida</h2>
<p>Gesten att 1948 ge judarna ett eget land, Israel, uppfattades därför av MSI som en manöver av andra världskrigets segrarmakter för att uppnå för dem viktiga utrikespolitiska mål. MSI vände sig mot vad de såg som ländernas plan att använda judarnas strävan efter en egen nation till att säkra kontrollen över Medelhavet. Vid Suezkrisen 1956 stod partiet på den egyptiske presidenten <strong>Nassers</strong> sida.</p>
<p>Under de första två decennierna av partiets existens var det också påfallande tyst i frågor som rörde Mussolinis politik mot judarna. Partiet tog inte avstånd från raslagarna och Salòrepublikens polisorder, vilken hade givit carte blanche till italiensk polis att gripa och internera judar.</p>
<p>I början av 1960-talet lades grunden till en förändrad syn på Israel. I den nyfascistiska tidningen <em>Il Secolo d’Italia</em> publicerades artiklar som kännetecknades av nyvunnen respekt för pionjärtanken och patriotismen i den unga judiska staten.<sup>4</sup></p>
<blockquote><p>Fortfarande hägrade emellertid en illa dold nostalgi för Mussolini inom många fraktioner av partiet.</p></blockquote>
<p>I samband med sexdagarskriget 1967 gjorde MSI en helomvändning i proisraelisk riktning. Därmed var de tidigare sympatierna för arabvärlden borta ur partiets program, som i stället var inriktat på samarbete med Väst. Den egyptiske presidenten, som tidigare hyllats, presenterades nu som en kryptokommunist som styrdes från Moskva. Israel framhölls som ett bålverk mot kommunismen.</p>
<p>Därmed försvann också den egentliga förutsättningen för antisemitism och antisionism i partiets breda lager. Samma år som sexdagarskriget ägde rum fördömde Almirante de raslagar som hade införts av Mussolini 1938. Men i extremistgrupper frodades fortfarande rasismen, och det manades till bojkott av MSI vid valurnorna 1968. Dessa grupper och andra påverkade inte MSI mer än ytterst marginellt, men har fortsatt att sprida ett extremistiskt och vulgärrasistiskt budskap, i flera fall rent nynazistiskt.</p>
<h2>Mot araberna och för Israel</h2>
<p>Förändringen i MSI kom också att påverkas av att partiet i början av 1970-talet slogs samman med ett rojalistiskt parti och ändrade namn till <em>Movimento Sociale Italiano – Destra Nazionale, </em>MSI-DN. Efter samgåendet uppnådde Almirantes parti det dittills bästa valresultatet med runt 9 procent i såväl valet till senaten (1971) som till kammaren (1972).</p>
<p>Vid Yom Kippur-kriget 1973 stod MSI fast vid den nya inställningen. Araberna sågs som Moskvas hantlangare och Israel hade all rätt att försvara sig.<sup>5 </sup>Samma år uttryckte MSI-politikern <strong>Giulio Caradonna</strong> solidaritet med Roms judar och skickade en hälsning till rabbinen <strong>Elio Toaff</strong>, som svarade: ”Stort tack för de vänliga och ädla uttrycken för solidaritet.” Samma år åkte Caradonna till Israel och lade blommor vid Förintelsens minnesplats Yad Vashem i Jerusalem, i rörelsens namn.<sup>6</sup></p>
<p>Fortfarande hägrade emellertid en illa dold nostalgi för Mussolini inom många fraktioner av partiet. Och trots att Almirante vid upprepade tillfällen bedyrade sin tro på demokratin framträdde han som en försvarare av diktaturerna i Spanien, Portugal och Grekland och påstod 1973 att kuppen i Chile kunde utgöra en modell för att hålla kommunisterna i schack även i Italien.<sup>7</sup></p>
<p>Under den reformprocess som fortsatte under 1980-talet såg MSI ett självklart värde att i rent egenintresse lyfta fram en fascist som under krigsåren uträttat humanistiska stordåd för judarna. Ljuset riktades mot <strong>Giorgio Perlasca</strong>, som i Budapest under 1944 och 1945 iklätt sig rollen som tillförordnad spansk ambassadör. Han bedöms ha räddat minst 5 200 judar senhösten 1944 och våren 1945. Partitidningen <em>Il Secolo d’Italia</em> ägnade 1989 en hel sida åt Perlasca. Den timide Perlasca värjde sig när han prisades för sina handlingar: ”Vem som helst i min position hade gjort samma sak.” <sup>8</sup></p>
<h2>Övertygad fascist</h2>
<p>Från sent 1920-tal hade Perlasca dock varit en övertygad fascist. Han hade deltagit i kriget i Etiopien och i spanska inbördeskriget på Francos sida. Man han var motståndare till alliansen med Tyskland och inte minst raslagarna, och distanserade sig från fascismen runt 1940. Hjälpt av sina näringslivskontakter hamnade han i Budapest och genom en lycklig omständighet fick han spanska identitetshandlingar, till stor del beroende på att han hade varit frivillig på Francosidan i inbördeskriget.</p>
<p>Uppmärksamheten mot Perlascas insatser sammanföll med den period då MSI fick en ny partiledare i <strong>Gianfranco Fini</strong>.</p>
<p>Fini föddes sex år efter andra världskrigets slut. När han i början av 1970-talet engagerade sig politiskt blev det som ungdomspolitiker i <em>Movimento Sociale Italiano</em>, den nyfascistiska rörelse som Almirante och andra grundat 1946. Det var den givna plantskolan för unga nyfascister. Redan 1977 vid 26 års ålder utsågs Fini till ordförande i partiets ungdomsfront.</p>
<p>Fini kom in i deputeradekammaren 1983 och valdes till partiledare i MSI-DN när Almirante gick bort 1988. Han slog ut rivalen <strong>Pino Rauti</strong>, som dock lyckades ta tillbaka ordförandeklubban under ett år efter den påföljande kongressen. Fini fick dock sin revansch och från 1992 var han åter partiledare.</p>
<p>Var Fini då den som gjorde partiet mer rumsrent?</p>
<p>Under de första åren fanns definitivt tvivel. Fini fortsatte att uttrycka sig entusiastiskt om fascismen som ideologi och menade att ”efter nästan ett halvt sekel är den fascistiska idén fortfarande levande” och att ”Mussolini är den störste italienske statsmannen under 1900-talet”.</p>
<h2>Tog ställning mot antisemitism</h2>
<p>I frågan om antisemitismen tog Fini tidigt ställning. I början av 1990-talet kunde han höras säga att ”antisemitismen är en idioti i teorin och ett brott i praktiken”.<sup>9 </sup>I december 1993 deltog han i en manifestation vid Fosse Ardeatine i Rom, där en nazistisk repressalieaktion hade ägt rum våren 1944, vid vilken ett 80-tal judar var bland de totalt 335 offren. Fini kom gradvis att inta en allt mer kritisk inställning till Mussoliniåren.</p>
<p>I partiet fanns emellertid en intern opposition, i första hand personifierad av tidigare nämnde Pino Rauti. Denne var djupt kritisk till den anpassning som Fini drev igenom. Konflikten fick sin klimax vid partikongressen i Fiuggi 1995, den första som arrangerades under det nya partinamnet <em>Alleanza Nazionale</em>, AN.</p>
<figure id="attachment_160268" aria-describedby="caption-attachment-160268" style="width: 2560px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-160268 size-full" src="https://kvartal.se/wp-content/uploads/2025/01/sdl9MXi_7IVJXg-scaled.jpg" alt="kvartal" width="2560" height="1707" data-wp-pid="160268" srcset="https://kvartal.se/wp-content/uploads/2025/01/sdl9MXi_7IVJXg-scaled.jpg 2560w, https://kvartal.se/wp-content/uploads/2025/01/sdl9MXi_7IVJXg-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/sdl9MXi_7IVJXg-768x512.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/sdl9MXi_7IVJXg-1536x1024.jpg 1536w, https://kvartal.se/wp-content/uploads/2025/01/sdl9MXi_7IVJXg-2048x1365.jpg 2048w, https://kvartal.se/wp-content/uploads/2025/01/sdl9MXi_7IVJXg-600x400.jpg 600w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-160268" class="wp-caption-text">Gianfranco Fini våren 2024. Foto: Cecilia Fabiano/TT</figcaption></figure>
<p>Kongressen beskrivs ofta som ”vändpunkten i Fiuggi”. Finis ambition var att förändra partiet i ren konservativ riktning, för att attrahera väljare från det nu upplösta kristdemokratiska partiet. Han kom att aktivt fördöma partimedlemmar som vid möten gjorde fascisthälsningen, och med kongressen i Fiuggi tog partiet aktivt avstånd från fascism och från all form av revolutionär inställning.</p>
<p>Vid kongressen i Fiuggi gjordes ett ”explicit och definitivt fördömande av alla former av antisemitism och antijudisk verksamhet … även om den är maskerad genom ett propagandistiskt sken av anti-sionism eller anti-israelisk retorik”.<sup>10</sup></p>
<p>Fiuggi representerar en betydande transformation av partiet. Under Finis ledning skedde en definitiv och slutgiltig anslutning till den liberala demokratin och en mer uttalat konservativ agenda blev resultatet. Partiet blev ett alternativ för väljare som tidigare stött kristdemokraterna. Vid valurnorna 1994 erhöll partiet 13,5 procent och två år senare nästan 16 procent. AN kom sedan att ingå i en koalitionsregering med bland annat <em>Lega Nord</em> och <strong>Silvio Berlusconis</strong> <em>Forza Italia</em>. Fini blev vice premiärminister 2001 och utsågs 2004 till utrikesminister.</p>
<h2>Bad om ursäkt</h2>
<p>Den 15 september 2002 publicerades en intervju med Gianfranco Fini i den israeliska tidningen <em>Ha’aretz</em>. Fini, som då var vice premiärminister, uttryckte att han talade för hela Italiens befolkning ”rörande det som hände i Italien efter införandet av raslagarna”. Han bad samtidigt det judiska folket om ”förlåtelse”.<sup>11</sup></p>
<p>Fini inbjöds sedan att besöka Israel och kan därmed sägas ha städat undan de sista resterna av antisemitism:</p>
<p style="padding-left: 40px;">”Vi bör göra det för att ta avstånd från de skamliga sidorna som finns i vår gemensamma historia … Vi bör göra det, inte så mycket för att stänga vår kontakt med historien, mer för att förbereda vår kultur.”</p>
<p>Kort därefter beslutade sig <strong>Alessandra Mussolini</strong>, barnbarn till diktatorn, att lämna AN, efter att länge ha varit aktiv inom partiet och dess föregångare MSI. Finis fördömande ord om hennes farfar var utan tvekan droppen som fick bägaren att rinna över.</p>
<p>Sex år efter Finis tal i Israel fusionerades <em>Alleanza Nazionale</em> med Berlusconis <em>Forza Italia</em> och bildade <em>Popolo della Libertà</em>. En mindre grupp bröt sig 2012 ur denna konstellation och bildade ett nytt parti, <em>Fratelli d’Italia</em>. I partiets ledning framträdde nu en ung kvinnlig politiker, <strong>Giorgia Meloni</strong>.</p>
<h2>Landets första kvinnliga premiärminister</h2>
<p>Melonis parti var 2018 ännu ett litet parti som endast samlade drygt 4 procent av rösterna. Men vid valet 2022 gick partiet fram som en ångvält; fler än var fjärde italienare röstade på Meloni, som därmed blev Italiens första kvinnliga premiärminister.</p>
<p>Partiets framgångar fortsatte sedan vid EU-valet 2024.</p>
<p>Partiet har en nationalkonservativ profil i mångt och mycket i den tappning som Gianfranco Fini lanserade 1995. På den internationella arenan har Meloni så långt samarbetat väl med EU och varit engagerad i Italiens stöd till Ukraina. Samtidigt kan man se partisymbolen, tre eldsflammor i den italienska trikolorens färger, som uttryck för en kontinuitet till den nyfascistiska rörelse som Giorgio Almirante bildade 1946.</p>
<figure id="attachment_160269" aria-describedby="caption-attachment-160269" style="width: 2560px" class="wp-caption alignnone"><img decoding="async" class="wp-image-160269 size-full" src="https://kvartal.se/wp-content/uploads/2025/01/sdlgdUN_IFL334-scaled.jpg" alt="kvartal" width="2560" height="1707" data-wp-pid="160269" srcset="https://kvartal.se/wp-content/uploads/2025/01/sdlgdUN_IFL334-scaled.jpg 2560w, https://kvartal.se/wp-content/uploads/2025/01/sdlgdUN_IFL334-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2025/01/sdlgdUN_IFL334-768x512.jpg 768w, https://kvartal.se/wp-content/uploads/2025/01/sdlgdUN_IFL334-1536x1024.jpg 1536w, https://kvartal.se/wp-content/uploads/2025/01/sdlgdUN_IFL334-2048x1365.jpg 2048w, https://kvartal.se/wp-content/uploads/2025/01/sdlgdUN_IFL334-600x400.jpg 600w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-160269" class="wp-caption-text">Giorgia Meloni under eldsflammorna i partisymbolen. Foto: Roberto Monaldo</figcaption></figure>
<p>När det gäller ämnet för denna essä har Giorgia Meloni i sina memoarer <em>Io sono Giorgia</em> fördömt raslagarna och Mussolinis väg till makten. Hon har varit konsekvent i sitt stöd för staten Israel och i sitt fördömande av antisemitismen. I oktober 2021 använde Meloni följande ord vid en minneshögtid över deportationerna från Rom i oktober 1943:</p>
<p style="padding-left: 40px;">”Razzian i Roms getto, ett verk av nazifascistisk terror, är ett djupt sår i varje italienare … Det som hände med den judiska gemenskapen i Rom, den äldsta i Europa, har rört vid våra gemensamma rötter. Antisemitismens virus är ännu inte utrotat, och det ska upprepas att vår insats behövs för att bekämpa det utan återhållsamhet, i varje form den tar sig uttryck, gammal som ny.”</p>
<p>Efter det att MSI från 1967 kom att inta en proisraelisk linje lades förutsättningen för att partiet också skulle kunna kritisera den antijudiska politiken som bedrevs i Mussolinis Italien. Den tydligaste vattendelaren är dock konferensen 1995 i Fiuggi; det är här som den definitiva förändringen av rörelsen sker och ett uttryckligt fördömande sker av all antisionism och antisemitism, även om den kläds i Israelkritik.</p>
<p>Meloni har sedan fortsatt på normaliseringens väg, vilken i den aktuella frågan präglats av ett fortsatt engagemang mot antisemitism och för staten Israel.<a href="#_ftnref1" name="_ftn1"></a></p>
<p><em>Anders Carlberg senaste bok heter &#8221;Mussolini mot Hitler – judarnas öde i fascismens Italien&#8221; (Santerus förlag 2024).</em></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="160214">  <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>Roberto Chiarini (Faccoltà di Scienze Politiche, Università degli Studi di Milano), 2007, Anti-Zionism and the Italian Extreme Right, sidan 22.</li>
<li>Almirante &amp; Palamenghi Crispi, 1958, 10-1, citerad, s. 25 i Chiarini.</li>
<li>Chiarini, s. 26</li>
<li>Scipione Rossi, s. 107</li>
<li>Scipione Rossi, s. 120f</li>
<li>Scipione Rossi, s. 122</li>
<li>Harman, 1988 och Ghiglione, Foreign Policy, 6.2.23.</li>
<li>Secolo d’Italia, 18.10.1989</li>
<li>Scipione Rossi, s. 270</li>
<li>Scipione Rossi, s. 270</li>
<li>Chiarini, s. 28, citerande Primor 2002.</li>
</ol>
</div>
</div>
<div class="author-byline">Anders Carlberg kommer i höst ut med boken &#8221;Mussolini mot Hitler &#8211; judarnas öde i fascismens Italien&#8221; och har tidigare skrivit &#8221;Hitlers lojala musiker&#8221; (2016) och &#8221;Toner och Terror&#8221; (2021). Samtliga böcker är utgivna på Santérus förlag.
</div>
</div>
