I korthet
Utrikesminister Tobias Billström (M) meddelade några dagar efter sin inflytt till Arvfurstens palats att den nya regeringen inte kommer att dra tillbaka Sveriges erkännande av Palestina. Detta trots att Moderaterna liksom övriga Tidöpartier var mycket kritiska till S-regeringens erkännande 2014.
“Men det förtjänar att ännu en gång uttalas”, framhöll utrikesministern, “hur olyckligt det var att göra en sådan åtgärd”.
<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-89398"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="89398" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfYXJfZGV0X255X2lzcmFlbHBvbGl0aWtfcGFfZ2FuZy5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvYXItZGV0LW55LWlzcmFlbHBvbGl0aWstcGEtZ2FuZ18ubXAz">  <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/daniel-schatz/">Daniel&nbsp;Schatz</a> | 14 mars 2023<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-det-ny-israelpolitik-pa-gang%2F&amp;t=%C3%84r+det+ny+Israelpolitik+p%C3%A5+g%C3%A5ng%3F"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=%C3%84r+det+ny+Israelpolitik+p%C3%A5+g%C3%A5ng%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-det-ny-israelpolitik-pa-gang%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-det-ny-israelpolitik-pa-gang%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är det ny Israelpolitik på gång?&body=https://kvartal.se/artiklar/ar-det-ny-israelpolitik-pa-gang/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/89398/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/89398/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf 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 author-section-external">  <div class="author-section-inner">    <div class="author-image-holder"><span class="icon-kvartal-hare"></span>    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Eventuella åsikter och slutsatser i texten är skribentens egna.    </div>  </div></div><div class="mobile-share clearfix" style="margin-top: -10px; margin-bottom: 20px;"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-det-ny-israelpolitik-pa-gang%2F&amp;t=%C3%84r+det+ny+Israelpolitik+p%C3%A5+g%C3%A5ng%3F"    target="_blank"    class="fb-link"    title="Dela på facebook"><i class="fa fa-facebook ui transparent"></i></a><a href   = "https://twitter.com/intent/tweet?text=%C3%84r+det+ny+Israelpolitik+p%C3%A5+g%C3%A5ng%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-det-ny-israelpolitik-pa-gang%2F"    target = "_blank"    class  = "tw-link"    title  = "Dela på X.com"><i class="exticon exticon-x-icon"></i></a></span><span class="share-inner"><a href   = "http://www.linkedin.com/shareArticle?mini=true&url=https%3A%2F%2Fkvartal.se%2Fartiklar%2Far-det-ny-israelpolitik-pa-gang%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Är det ny Israelpolitik på gång?&body=https://kvartal.se/artiklar/ar-det-ny-israelpolitik-pa-gang/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/89398/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a><a href   = "https://kvartal.se/skriv-ut/89398/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/ar-det-ny-israelpolitik-pa-gang/?inlast=1">  <i class="fas fa-headphones-alt"></i>  <span>Inlästa texter</span></a><a href="#nyhetsbrevet" onclick="newsletter()" class="newsletter"><i class="fas fa-paper-plane"></i><span>Nyhetsbrev</span></a><a class="reading-time" title="Ungefärlig lästid"><i class="far fa-clock ui"></i><span>Lästid 11 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/89398"    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-89398">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "89398"></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 ">Utrikesminister <strong>Tobias Billström</strong> (M) meddelade några dagar efter sin inflytt till Arvfurstens palats att den nya regeringen inte kommer att dra tillbaka Sveriges erkännande av Palestina. Detta trots att Moderaterna liksom övriga Tidöpartier var mycket kritiska till S-regeringens erkännande 2014.</p>
<p>“Men det förtjänar att ännu en gång uttalas”, framhöll utrikesministern, “hur olyckligt det var att göra en sådan åtgärd”.</p>
</div>
<div class="rest-of-article ">
<p>Billströms utspel – i kombination med regeringens planer att dra ner Sveriges bistånd till den palestinska myndigheten med 40 till 60 procent – har väckt frågan om en förändring av svensk Mellanösternpolitik är nära förestående?</p>
<h2>Turbulent relation under 2010-talet</h2>
<p>Sveriges relationer till Israel och palestinierna präglades av turbulens under <strong>Stefan Löfvens</strong> (S) tid som statsminister. Den tidigare regeringen hann knappt flytta in i Rosenbad innan Sverige – som första medlemsland inom EU – erkände en palestinsk stat. Erkännandet togs emot med glädje hos den palestinska myndigheten samtidigt som de diplomatiska förbindelserna med Israel lamslogs. De gjorde allt för att avskräcka andra länder från att följa det svenska exemplet.</p>
<p>Den israeliske utrikesministern <strong>Avigdor Lieberman</strong> kallade hem landets Stockholmsambassadör och påpekade syrligt att Sveriges regering måste förstå att Mellanösternkonflikten är mer komplicerad än att montera ihop Ikea-möbler. Samtidigt kallades den svenska ambassadören i Israel upp till israeliska UD ett flertal gånger för att ta emot landets skarpa kritik.</p>
<p>Efter en rad diplomatiska kontroverser förklarade Israel år 2016 att <strong>Margot Wallström</strong> (S) – som den enda av EU-ländernas 28 utrikesministrar – inte var välkommen i landet. De svensk-israeliska relationerna lamslogs, vilket illustrerades av att landets utrikesministrar inte talade med varandra på sex år.</p>
<p>Islossningen dröjde ända till 2021 när <strong>Ann Linde</strong> (S) genomförde det första svenska utrikesministerbesöket till Israel på tio år. “Både jag och statsministern har medvetet jobbat för att normalisera relationerna med Israel. Vi har sett vad vi kan göra för att visa att vi är seriösa i vår vilja”, framhöll Linde efter ett möte i Jerusalem med den israeliske utrikesministern <strong>Yair Lapid</strong>, vars familj räddades undan Förintelsen av <strong>Raoul Wallenberg</strong>.</p>
<p>Stefan Löfvens personliga initiativ att bjuda in stats- och regeringschefer till Malmö internationella forum för hågkomst av Förintelsen och bekämpande av antisemitism samma år bidrog till att tina upp de stelfrusna förbindelserna. Statsministern hade redan talat varmt om Israels utveckling när landets 70-årsdag firades i Stockholm 2018, utan att denna hållning fått genomslag i den förda Mellanösternpolitiken.</p>
<h2>Tusenårigt intresse</h2>
<p>Den turbulens som präglat Sveriges relationer med Israel och palestinierna reflekterar ett svenskt intresse för det heliga landet som kan spåras ända tillbaka till runinskrifter från 1000-talet som vittnar om vikingaexpeditioner till Jorsala, det fornnordiska namnet på Jerusalem. Enstaka korsriddare tar sig dit, medan höjdpunkten är <strong>Heliga Birgittas</strong> pilgrimsfärd 1372.</p>
<p>Med tiden reser en ström av svenska författare, vetenskapsmän och teologer till den omstridda landremsan mellan Medelhavet och Jordanfloden. Bland dessa återfinns <strong>Carl von Linné</strong>, <strong>Fredrika Bremer</strong> och <strong>Selma Lagerlöf</strong>, vars epos Jerusalem beskriver hur Nåsbönderna i Dalarna – högsjungandes ”vi vandra till Sion” – utvandrar för att söka frälsning i det Heliga landet under slutet av 1800-talet.</p>
<p>Det religiöst färgade intresset ersätts snart med ett svenskt politiskt engagemang i regionen. Statsminister<strong> Hjalmar Branting</strong> uttalar stöd för den sionistiska rörelsen på 1920-talet medan justitierådet <strong>Emil Sandström</strong> utses till ordförande i den FN-kommitté som 1947 föreslår en delning av det brittiska Palestinamandatet i en judisk och arabisk stat. Samma år röstar Sverige, som ett av 33 länder, för FN:s delningsplan för Palestina, vilket leder till staten Israels grundande.</p>
<p>Dramatiken när ett folk, som näst intill hade utrotats under Förintelsens fasor, utropar och försvarar sin stat engagerar breda folklager i Sverige. Den välvilliga inställningen får sig en törn när den militanta Sternligan 1948 mördar <strong>Folke Bernadotte</strong>, FN:s första medlare i den arabisk-israeliska konflikten, vid en vägspärr i Jerusalem. Brorsonen till dåvarande kung <strong>Gustav V</strong> hade tidigare mötts av hätska protester under parollen ”Stockholm är ditt – Jerusalem är vårt”. Mordet faller dock snart i glömska när Sverige erkänner Israel de jure två år efter landets grundande, trots att Bernadottes mördare så småningom blev livvakt till Israels förste premiärminister, <strong>David Ben-Gurion</strong>.</p>
<h2>Blomstrande förbindelser</h2>
<p>Vänskapsförbindelserna, som blomstrar under <strong>Tage Erlanders</strong> (S) resterande statsministertid, kulminerar när Erlander och Israels premiärminister David Ben-Gurion besöker varandras länder under 1960-talet.</p>
<p>Erlander framhåller under Israelbesöket att “vi har lärt oss om det gamla Israel i skolan, som vi läst i Bibeln, och det nya Israel, som ni har skapat med era egna händer och ert eget arbete”. Han avslutar med att konstatera att “vi är fulla av beundran för ert sant heroiska ansträngningar med att bygga en modern välfärdsstat och en socialdemokrati i detta era fäders land”.</p>
<blockquote><p>Gemensamt för alla svenskar var att Israel var ett välbekant land.</p></blockquote>
<p>Erlanders uttalanden symboliserar den instinktivt känslomässiga och nostalgiska sympati som ledande socialdemokrater kände med det judiska statsprojektet. Båda länderna formades av sina statsbärande socialdemokratiska partier som dominerade politik, ekonomi och samhällsliv; Sverige får sitt första politiska maktskifte i modern tid 1976, Israel ett år senare.</p>
<figure id="attachment_89629" aria-describedby="caption-attachment-89629" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-89629 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/sdlN0JUrbjUsNI-nl.jpg" alt="" width="1024" height="720" data-wp-pid="89629" srcset="https://kvartal.se/wp-content/uploads/2023/03/sdlN0JUrbjUsNI-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/03/sdlN0JUrbjUsNI-nl-600x422.jpg 600w, https://kvartal.se/wp-content/uploads/2023/03/sdlN0JUrbjUsNI-nl-300x211.jpg 300w, https://kvartal.se/wp-content/uploads/2023/03/sdlN0JUrbjUsNI-nl-768x540.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-89629" class="wp-caption-text">Tage Erlander badar i Döda havet under sitt besök i Israel 1962. Foto: TT Nyhetsbyrån.</figcaption></figure>
<p>De fann i Israel visionen av en demokratisk och socialistisk välfärdsstat i en feodal och reaktionär region, tydligast manifesterad i kibbutzernas kollektivjordbruk där många svenskar och aktiva socialdemokrater volontärarbetade. Dessa förbindelser förstärktes av täta kontakter mellan svenska LO och den inflytelserika israeliska fackföreningsrörelsen <em>Histadrut</em>.</p>
<p>Den breda svenska och internationella Israelvänliga opinionen såg den judiska staten som ett nödvändigt svar på nazismens brott mot mänskligheten. Gemensamt för alla svenskar var att Israel var ett välbekant land. Sverige var under 1950- och 1960-talen mindre sekulariserat än idag. Skoldagen började med morgonbön och kartor över det Heliga landet prydde folkskolornas klassrum. En skåning var ofta mer hemmastadd med ortsnamn som Betlehem och Nasaret än Lycksele och Sorsele, vilket skapade en koppling till det moderna Israel.</p>
<blockquote><p>Olof Palme träffar som förste västerländska statsminister Yassir Arafat 1974 under ett besök i Alger samtidigt som Israel betraktar Arafat som en ärketerrorist.</p></blockquote>
<p>I Sverige personifieras denna inställning av Erlander som uttalade stöd för Israel som den svagare parten i den arabisk-israeliska konflikten. Samtidigt uppmanades arabstaterna att erkänna den judiska statens rätt att existera innanför säkra och internationellt erkända gränser. Ansvaret för konfliktens utbrott lades på arabstaterna, utifrån en syn på Israel som en demokratisk David som kämpade för sin överlevnad mot en mäktig och diktatorisk Goliat.</p>
<p>Denna hållning exemplifieras av Erlander i ett tal vid TCO-kongressen 1967 där han fastslår att sexdagarskrigets start tillhör de mörkare dagarna i hans liv eftersom den judiska statens existens är hotad. Stödet för Israel var inte unikt för Sverige utan dominerade västeuropeiska attityder till konflikten fram till PLO:s grundande 1964, sexdagarskriget 1967 och den palestinska nationella rörelsens uppkomst på 1970-talet.</p>
<h2>Opinionen svänger</h2>
<p>Efter många års entusiastiskt stöd för Israel började den internationella opinionen svänga efter sexdagarskrigets slut, då den utsatta judiska staten inte tycktes vara lika hotad som tidigare. Statsminister <strong>Olof Palme</strong> (S) gick i bräschen för denna syn. Nu upptäcker socialdemokratin palestinierna, det andra folket som bor mellan Medelhavet och Jordanfloden, medan Israel förlorar mycket av sympatin.</p>
<p>Olof Palme träffar som första västerländska statsminister <strong>Yassir Arafat</strong> 1974 under ett besök i Alger samtidigt som Israel betraktar Arafat som en ärketerrorist. Palme kommer snabbt att inta rollen som en av PLO:s främsta supportrar i Västeuropa.</p>
<p>Palestinierna – som tidigare setts som ett humanitärt flyktingproblem – erkänns som ett folk med nationella rättigheter, och som huvudpart i en nationell konflikt om rätten till samma territorium. Samtidigt får PLO status som det palestinska folkets mest auktoritativa talesperson. Organisationen öppnar ett representationskontor i Stockholm – under starka protester från Israel.</p>
<p>Konflikten når sin kulmen i samband med att Arafat bjuds in till Sverige 1983; ett besök som släpper in PLO-ledaren i den internationella solidaritetens finrum. De borgerliga partiledarna, som nu intagit roller som Israels främsta försvarare i svensk samhällsdebatt, protesterar högljutt och vägrar träffa honom.</p>
<p>Mellanösternpolitikens förändring var kopplad till Palmes aktivistiska utrikespolitik. Den var baserad på stöd till självproklamerade självständighets- och befrielserörelser i tredje världen, organisationer som FN och en fredlig lösning av internationella konflikter liksom kritik mot kränkningar av internationell rätt och mänskliga rättigheter. Genom segern i sexdagarskriget hade den judiska staten, i Palmes ögon, förvandlats till en militärt överlägsen ockupationsmakt.</p>
<figure id="attachment_89635" aria-describedby="caption-attachment-89635" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-89635 size-full" src="https://kvartal.se/wp-content/uploads/2023/03/sdl6SJyNn4Tfjw-nl.jpg" alt="" width="1024" height="771" data-wp-pid="89635" srcset="https://kvartal.se/wp-content/uploads/2023/03/sdl6SJyNn4Tfjw-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/03/sdl6SJyNn4Tfjw-nl-600x452.jpg 600w, https://kvartal.se/wp-content/uploads/2023/03/sdl6SJyNn4Tfjw-nl-300x226.jpg 300w, https://kvartal.se/wp-content/uploads/2023/03/sdl6SJyNn4Tfjw-nl-768x578.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-89635" class="wp-caption-text">Yassir Arafat och Olof Palme möts i Stockholm 1983. Foto: Bertil Ericson /TT</figcaption></figure>
<p>68-vänsterns inverkan på svensk utrikesdebatt – i kombination med en ung generation socialdemokratiska ledare som var födda efter andra världskriget och saknade Erlandergenerationens identifiering med Israel – ledde till sympati med palestinierna som den svagare parten i konflikten, i linje med de principer som Sveriges utrikespolitik sade sig vilja upprätthålla. Israels legendariske FN-ambassadör <strong>Chaim Herzog</strong> karaktäriserade den nya svenska hållningen som &#8221;ett skamligt svek&#8221; och konstaterade att “det kändes som om vi hade blivit knivhuggna i ryggen av ett vänligt land som inte ens skulle ha en kniv”.</p>
<p>Mellanösternpolitiken upprätthölls efter mordet på Palme av <strong>Sten Andersson</strong> – Socialdemokraternas mångårige partisekreterare (1962–82) och utrikesminister (1985–91). Denne förkämpe för den palestinska saken och personliga vän till Arafat utsågs till Sveriges särskilda representant för fredsprocessen i Mellanöstern 1994 och fortsatte att utöva inflytande över förbindelserna med Israel och palestinierna.</p>
<h2>Normalisering under Persson-eran</h2>
<p>Palme-erans Mellanösternpolitik präglas av kontinuitet utan större förändringar tills Göran Persson (S) blir statsminister samtidigt som en förhandlingsvänlig socialdemokratisk regering vinner det israeliska valet 1999.</p>
<p>Jag visar i min doktorsavhandling <em>Leaders matter. Foreign policy change in Sweden’s Middle East policy 1999-2001</em> hur Persson upprätthåller banden med palestinierna samtidigt som relationerna med Israel normaliseras. Persson hade formats av den tidiga socialdemokratiska synen på Israel som regionens enda demokrati och en stat som etablerats av socialistiska pionjärer i Förintelsens fotspår. För honom var detta den stora solidaritetsfrågan.</p>
<p>&#8221;Femtio år med staten Israel är också femtio år med den väsentliga övertygelsen om att Förintelsen aldrig får upprepas&#8221;, säger statsministern i samband med firandet av Israels femtioårsjubileum i Stockholm 1998, som markerade policyförändringens början. Han drar slutsatsen att “staten Israel är och förblir en omistlig del av världssamfundet, en demokrati som i en uppriktig dialog med andra demokratier för fram och tar emot kritik och ståndpunkter, ett land med rätt till bestående fred inom säkra och erkända gränser”.</p>
<p>Göran Persson blir den första svenska statsminister som besöker Israel sedan Erlanders besök mer än 30 år tidigare. Han driver igenom policyförändringen i nära samverkan med sin statssekreterare <strong>Pär Nuder</strong>, trots högljudda protester från partikamrater som Sten Andersson och Anna Lindh. Persson marginaliserar utrikesdepartementet i policyförändringsprocessen, som han tyckte hade institutionaliserat Palmes förlegade Mellanösternpolitik, som ensidigt betraktade palestinierna som den svagare parten och sällan talade om Israels sårbarhet.</p>
<p>Han karaktäriserar skämtsamt UD:s biståndsavdelning som en underavdelning till PLO.</p>
<h2>En central roll i förhandlingarna</h2>
<p>Resultatet av Perssons oväntade schackdrag – och ett målmedvetet brobyggande av Pär Nuder – blev att Sverige under en tid kom att spela en central roll i fredsförhandlingarna i Mellanöstern som värd för två omgångar hemliga israelisk–palestinska fredsförhandlingar på Harpsund år 2000.</p>
<p>Israeliska, palestinska och amerikanska förhandlare vittnar om betydande framsteg under samtalen i statsministerns rekreationsbostad. Den amerikanske chefsförhandlaren <strong>Dennis Ross</strong> betonade i efterföljande samtal med Arafat att ”real business was done” i Sverige och karaktäriserade Harpsundsspåret som de första riktigt substantiella förhandlingarna om kärnfrågorna i den israelisk-palestinska konflikten.</p>
<p>Vad säger den historiska utvecklingen om Sveriges framtida relationer med konfliktens parter? Trots att de nuvarande regeringspartierna verkat för att förstärka Sveriges relationer med Israel i opposition, har samtliga genomgripande förändringar av svensk Mellanösternpolitik genomförts under S-ledda regeringar.</p>
<blockquote><p>Bildt besöker Israel 2011 vilket blir det sista svenska utrikesministerbesöket på tio år.</p></blockquote>
<p>De borgerliga regeringarna 1976–1981 och 1991–1994 höll i stort sett samma linje som Olof Palme, även om retoriken till stöd för den palestinska saken tonades ner. Trots att Alliansregeringen, som tillträdde 2006, utökade ministerutbytena med Israel återknöt utrikesminister <strong>Carl Bildt</strong> (M) – ironiskt nog – till Palmelinjen där grundandet av en palestinsk stat oväntat gjordes till en borgerlig hjärtefråga.</p>
<p>Medan oppositionen jublade åt Bildts engagemang i pro-palestinsk riktning, ifrågasattes utrikesministerns Israelkritik upprepade gånger av Folkpartiet, Kristdemokraterna och delar av den moderata riksdagsgruppen, som argumenterat för en mer balanserad Mellanösternpolitik. Den interna oppositionen hade föga inverkan på den förda politiken. Det illustrerades av Bildts Mellanösternuttalanden, liksom antagandet av rådslutsatser under det svenska EU-ordförandeskapet 2009 om Jerusalem som delad huvudstad för två stater där Palestina nämndes vid namn, som blivande stat.</p>
<p>Relationerna med Israel svalnade ytterligare genom uppgraderingen av det palestinska representationskontoret i Stockholm till en ambassad 2012, trots protester från Folkpartiet som menade att beslutet var taget på egen hand av Bildt.</p>
<h2>Bildt inte välkommen</h2>
<p>Bildt besöker Israel 2011 vilket blir det sista svenska utrikesministerbesöket på tio år. Han förklaras, efter en rad återkommande sammandrabbningar med Israel inofficiellt ”icke önskvärd” i Jerusalem, även om detta inte uppmärksammas lika mycket som när samma stämpel senare drabbade Margot Wallström. Förutsättningarna för meningsfulla samtal ansågs så obefintliga att Bildt inte längre var välkommen i Israel.</p>
<p>Medan samtliga Tidöpartier i det nuvarande regeringsunderlaget gick till val på att förstärka Sveriges relationer med Israel, väntas Mellanösternpolitiken inte stå överst på den utrikespolitiska dagordningen som domineras av kriget i Ukraina och hanteringen av Sveriges Natoansökan.</p>
<p>Regeringens utrikesdeklaration som presenterades i februari lämnade frågor obesvarade om politikens inriktning. I en kortfattad formulering som återspeglar en långsiktig hållning betonas att &#8221;Sverige kommer att arbeta för en tvåstatslösning baserad på internationell rätt avseende Israel-Palestina&#8221;.</p>
<p>Samtidigt var tidigare tillägg från Löfvenregeringen om att &#8221;regeringen vill upprätthålla goda relationer med både Israel och Palestina&#8221;; och att &#8221;vi stödjer Israels legitima säkerhetsbehov&#8221;; borttagna från dokumentet.</p>
<p>Den sittande regeringen, där flera uttalade Israelvänner ingår, förväntas dock överlag föra en mer Israelvänlig politik än den tidigare, samtidigt som relationerna med palestinierna vidmakthålls och målsättningen om en framförhandlad tvåstatslösning av Mellanösternkonflikten baserad på internationell rätt kvarstår.</p>
<p>Kristdemokraterna, Liberalerna och Sverigedemokraterna har även fattat formella beslut om att verka för en flytt av Sverige ambassad i Israel från Tel Aviv till huvudstaden Jerusalem, vilket avvisats av Billström i väntan på ett slutgiltigt israeliskt-palestinskt fredsavtal.</p>
<p>Det återstår att se om denna hållning kommer att beseglas med en ny genomgående förändring av svensk Mellanösternpolitik.</p>
<div class="author-byline">Daniel Schatz är fil.dr. i statsvetenskap, gästforskare vid Georgetown University och fri skribent. Han har tidigare varit gästforskare vid Harvard, Stanford och Columbia och han skriver en bok om Sveriges Mellanösternpolitik.
</div>
</div>
