133 miljarder i bistånd till länderna som kampanjar mot Sverige

<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-116037"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="116037" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="MTMzIG1pbGphcmRlciBpIGJpc3TDpW5kIHRpbGwgbMOkbmRlcm5hIHNvbSBrYW1wYW5qYXIgbW90IFN2ZXJpZ2U=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9qci0xMzMtbWlsamFyZGVyLWktYmlzdGFuZC10aWxsLWxhbmRlcm5hLXNvbS1rYW1wYW5qYXItbW90LXN2ZXJpZ2UtNi0zNS1tYXN0cmFkLm1wMw==" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvanItMTMzLW1pbGphcmRlci1pLWJpc3RhbmQtdGlsbC1sYW5kZXJuYS1zb20ta2FtcGFuamFyLW1vdC1zdmVyaWdlLTYtMzUtbWFzdHJhZC5tcDM=">  <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/lars-aberg/">Lars&nbsp;Åberg</a> och <a href="https://kvartal.se/medverkande/johan-frisk/">Johan&nbsp;Frisk</a> | 5 december 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%2F133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige%2F&amp;t=133+miljarder+i+bist%C3%A5nd+till+l%C3%A4nderna+som+kampanjar+mot+Sverige"    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=133+miljarder+i+bist%C3%A5nd+till+l%C3%A4nderna+som+kampanjar+mot+Sverige+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2F133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige%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%2F133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=133 miljarder i bistånd till länderna som kampanjar mot Sverige&body=https://kvartal.se/artiklar/133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/116037/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%2F133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige%2F&amp;t=133+miljarder+i+bist%C3%A5nd+till+l%C3%A4nderna+som+kampanjar+mot+Sverige"    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=133+miljarder+i+bist%C3%A5nd+till+l%C3%A4nderna+som+kampanjar+mot+Sverige+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2F133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige%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%2F133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=133 miljarder i bistånd till länderna som kampanjar mot Sverige&body=https://kvartal.se/artiklar/133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/116037/utskrift"    target  = "_blank"    class   = "pr-link"    title   = "Skriv ut"    onclick = ""><i class="ti-printer ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/133-miljarder-i-bistand-till-landerna-som-kampanjar-mot-sverige/?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 9 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/116037"    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-116037">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "116037"></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 ">De muslimska staternas samarbetsorganisation OIC har i skarpa ordalag fördömt Sverige för koranbränningarna. I FN verkar OIC för att Sverige ska införa blasfemilagar. Samtidigt har OIC-länderna länge tagit emot svenskt bistånd – sammanlagt inte mindre än 133 miljarder kronor de senaste 25 åren.</p>
</div>
<div class="rest-of-article ">
<p>Det visar data som Kvartal ställt samman med hjälp av statistik från Openaid, en webbplats som samlar uppgifter om det svenska biståndet. För varje OIC-land har det totala biståndet sedan 1998 tagits fram, år för år i löpande priser, och sedan lagts ihop för att få fram summan för hela organisationen. De siffror som Kvartal visar är totalsummor över bistånd från samtliga myndigheter och departement.</p>
<figure id="attachment_116201" aria-describedby="caption-attachment-116201" style="width: 1280px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-116201 size-full" src="https://kvartal.se/wp-content/uploads/2023/12/Tisdag-V49-Graf-2-kopia.jpg" alt="" width="1280" height="649" data-wp-pid="116201" srcset="https://kvartal.se/wp-content/uploads/2023/12/Tisdag-V49-Graf-2-kopia.jpg 1280w, https://kvartal.se/wp-content/uploads/2023/12/Tisdag-V49-Graf-2-kopia-600x304.jpg 600w, https://kvartal.se/wp-content/uploads/2023/12/Tisdag-V49-Graf-2-kopia-300x152.jpg 300w, https://kvartal.se/wp-content/uploads/2023/12/Tisdag-V49-Graf-2-kopia-768x389.jpg 768w" sizes="(max-width: 1280px) 100vw, 1280px" /><figcaption id="caption-attachment-116201" class="wp-caption-text"><em>Beloppen är i respektive års penningvärde. Källa: Openaid.</em></figcaption></figure>
<p>Som framgår av grafiken har beloppen ökat stadigt under både socialdemokratiska och borgerliga regeringar, med en topp 2021, för att sedan minska de två senaste åren och är nu nere på samma nivå som under <strong>Stefan Löfvens</strong> regeringstid 2016.</p>
<p>Man skulle här kunna tala om otack som världens lön.</p>
<p>OIC står för <em>Organisation of Islamic Cooperation</em> och bildades 1969 med säte i Jeddah i Saudiarabien. Samtidigt som 47 av organisationens 57 medlemsstater fått ekonomiskt stöd från Sverige vill de påverka hur yttrandefriheten hanteras i det lilla avlägsna landet vid polcirkeln. De har underblåst kampanjen mot Sverige som ett antimuslimskt land och samtidigt bortsett från att Sverige tagit emot hundratusentals människor som flyttat hit från länder som är medlemmar i OIC.</p>
<p>Någon beräkning av kostnaderna för migrationen från länder inom OIC till Sverige lär bli svår att finna. Om den ska göras fullständig bör den också inkludera utgifter för LVU-omhändertaganden och koranbränningar, bland annat polisinsatserna och förstörelsen i samband med kravallerna i flera svenska städer påsken 2022.</p>
<p>Syrierna är den största invandrargruppen i Sverige; cirka 250 000 personer har syrisk bakgrund. Ungefär 145 000 har irakisk bakgrund, 110 000 har somalisk bakgrund och 75 000 har afghansk bakgrund.</p>
<h2>Sveriges bistånd lovordas i internationell utvärdering</h2>
<p>I biståndsbudgeten för 2023 finns dessutom 4,2 miljarder för asylmottagandet, som berör flera OIC-länder, och 3,4 miljarder för det gemensamt administrerade EU-biståndet.</p>
<p>De största biståndsmottagarna bland OIC-staterna har det senaste kvartsseklet varit:</p>
<ul>
<li>Afghanistan 16,7 miljarder</li>
<li>Moçambique 16,4 miljarder</li>
<li>Palestina 10,7 miljarder</li>
<li>Uganda 9,9 miljarder</li>
<li>Somalia 9,7 miljarder</li>
<li>Bangladesh 7,7 miljarder</li>
<li>Sudan 7,1 miljarder</li>
<li>Irak 7 miljarder</li>
<li>Syrien 5,8 miljarder</li>
<li>Mali 5,6 miljarder</li>
<li>Burkina Faso 4,7 miljarder</li>
<li>Jemen 3,8 miljarder</li>
<li>Turkiet 2 miljarder</li>
<li>Nigeria 2 miljarder</li>
<li>Pakistan 2 miljarder</li>
</ul>
<p>Sverige gav naturligtvis bistånd även före 1998, men omfattningen har ökat successivt. Det tidigare biståndet redovisades i andra statistiska system än det som nu används av Openaid. Siffrorna från de senaste 25 åren ger emellertid en bra bild av hur biståndsmedlen har fördelats.</p>
<p>Bland biståndsmottagarna märks Turkiet, som har blockerat det svenska Natomedlemskapet genom krav på lagändringar och utlämning av personer som president <strong>Recep Tayyip Erdoğan</strong> ser som politiska motståndare.</p>
<blockquote><p>Flera mottagarländer har samtidigt blivit mindre demokratiska och mer radikalt islamistiska.</p></blockquote>
<p>Enligt biståndsmyndigheten Sida är målet för Sveriges bistånd att skapa förutsättningar för människor som lever i fattigdom och under förtryck att själva förändra sina liv. ”En mer demokratisk, jämställd, rättvis, hållbar och fredlig värld är bra för alla”, skriver Sida på sin hemsida. Vid internationella jämförelser framhålls Sverige ofta som ett föredöme på det här området. Av den ekonomiska samarbetsorganisationen OECD:s biståndskommitté lovordades Sverige i en rapport häromåret för sitt generösa bistånd, sitt pålitliga stöd vid katastrofer och sitt ledarskap i fråga om konfliktlösning, klimatarbete och jämställdhet.<sup>1</sup></p>
<p>I en utvärdering 2021 bedömdes biståndet som ”relevant och effektivt”. Särskilt insatserna när det gäller jämställdhet mellan könen lyftes fram: ”de har helt klart haft effekt”.<sup>2</sup></p>
<p>Men flera mottagarländer har samtidigt blivit mindre demokratiska och mer radikalt islamistiska. Bland de fem största biståndsmottagarna märks här Afghanistan, Palestina och Somalia.</p>
<p>Man bör komma ihåg att endast en mindre del av biståndet går direkt till den berörda staten. När det exempelvis gäller det stora biståndslandet Moçambique, som tagit emot mer än 16 miljarder kronor, hamnade 19 procent av fjolårets utbetalning hos den offentliga sektorn på central nivå. Mer än 40 procent gick till olika organisationer i landet.<sup>3</sup> Organisationernas identitet offentliggörs inte alltid och skälet är vanligtvis att stödet går till sådana som arbetar med frågor som gör att de inte är väl sedda i partnerlandet, enligt <strong>Jan Pettersson</strong>, kanslichef på EBA, den statliga Expertgruppen för biståndsanalys. Frågan om biståndets effekt är komplicerad, det finns naturligtvis en möjlighet att den typen av stöd bidrar till att vissa regimer blir mer benägna att slå tillbaka genom att kritisera Sverige.</p>
<p>Han berättar att EBA har gjort egna utvärderingar av biståndet till bland annat Afghanistan och Turkiet. Som han ser det är den relevanta frågan inte om stödet har bidragit till en positiv förändring utan i vilken mån det lyckas motverka en ännu kraftigare försämring.</p>
<h2>OIC-ländernas roll i desinformationskampanjen</h2>
<p>Det var för två år sedan som desinformationskampanjen om att svensk socialtjänst kidnappade muslimska barn började spridas på arabisktalande konton på sociala medier. I en rapport från Försvarshögskolan pekas flera internationella predikanter och nätaktörer ut som drivande.<sup>4</sup></p>
<p>Kampanjen växte snabbt i styrka och omfång med påståenden om att myndigheterna omhändertog barn utan anledning med stöd av LVU, lagen om vård av unga. Uppgifterna spreds också av internationella nyhetsmedier som <em>Al Jazeera</em>, med bas i OIC-landet Qatar, och turkiska <em>TRT</em>. Därefter har kommuner och anställda inom socialtjänsten blivit hotade, och i kommentarsfält på sociala medier har terrorhot riktats mot Sverige.</p>
<p>Den negativa uppfattningen om Sverige har sedan blivit än mer fientlig efter koranbränningarna i år och i fjol. Även här utgörs kärnan av desinformation; svenska myndigheter påstås ge tillstånd för att bränna Koranen när det har handlat om demonstrationstillstånd. De senaste veckorna har det också på nätet spridits en medvetet felaktig version av vad statsminister <strong>Ulf Kristersson</strong> sa på ett möte i Göteborg om kriget mellan Israel och Hamas.</p>
<p>I juli i år förklarade Irans ledare, ayatolla <strong>Ali Khamenei</strong>, att om man stödjer brott mot den islamiska världen är det liktydigt med förberedelse för krig: ”Det är den svenska regeringens skyldighet att lämna över brottslingen som brände den heliga Koranen till rättssystemet i muslimska länder.”<sup>5</sup> Biståndet från Sverige till Iran har uppgått till nästan 188 miljoner kronor, men vid sidan om humanitärt stöd handlar det idag mest om betalning för studieplatser i Sverige.</p>
<p>Ett par dagar tidigare hade en mobb stormat och satt eld på den svenska ambassaden i Bagdad i Irak, ett land som Sverige gett sju miljarder kronor till. Hizbollahs ledare <strong>Hassan Nasrallah</strong> krävde att Sveriges ambassadör i Libanon skulle utvisas. Lilla Libanon med 5,5 miljoner invånare har fått över 1,2 miljarder kronor av Sverige.</p>
<p>Säkerhetspolisen tvingades höja hotnivån i Sverige till fyra på en femgradig skala. I oktober dödade en terrorist två svenskar i Bryssel i samband med en EM-kvalmatch i fotboll.</p>
<p>Jan Pettersson på Expertgruppen för biståndsanalys tycker att det ska bli intressant att se vilket genomslag det här händelseförloppet får i Sidas årliga opinionsundersökning av svenska folkets syn på biståndet. På kort sikt riskerar kampanjen att utsätta enskilda svenskar för risker, och då även biståndsarbetare, men på längre sikt tror han att effekterna bestäms av både vilka andra saker som inträffar och hur långvariga koranaktionerna och LVU-protesterna blir.</p>
<h2>Religion vs mänskliga rättigheter</h2>
<p>I januari i år kritiserade OIC:s generalsekreterare <strong>Hissein Brahim Taha</strong> det han såg som upprepade provokationer i Sverige som ”riktar sig mot muslimer, förolämpar deras heliga värden och tjänar som ytterligare exempel på en alarmerande nivå av islamofobi, hat, intolerans och främlingsfientlighet”. Taha kommer från Tchad, som fått drygt 1,3 miljarder kronor från Sverige.</p>
<p>OIC:s representation vid FN i New York förklarade i somras att det är nödvändigt att ”anti-muslimskt hat” stoppas och att förövarna ställs inför rätta. Samtidigt har OIC inte velat kritisera Kina, som massinternerar muslimer i läger och bedriver en kampanj för att riva moskéer.</p>
<p>Den 19 september möttes Hissein Brahim Taha och <strong>Tobias Billström</strong> i New York. Den svenske utrikesministern betonade att den svenska regeringen är emot de här aktionerna och därför tänker se över ordningslagen för att hitta en lösning.</p>
<p>I botten på kampanjerna mot Sverige finns en värderingskonflikt med fundamentalt skilda uppfattningar om familjens ställning och individens rättigheter. Ett av OIC:s centrala dokument är Kairodeklarationen från 1990, undertecknad av medlemsländernas utrikesministrar. Den har udden riktad mot FN:s universella människorättsdeklaration och presenterar en alternativ världsåskådning, som leder fram till att religiösa sharialagar står över nationell lagstiftning.</p>
<p>Av texten framgår att det är förbjudet att lämna islam och att synen på yttrandefrihet och jämställdhet skiljer sig starkt från den västerländska.</p>
<p>Trots den stora svenska givmildheten verkar den inte ha lett till folklig <em>goodwill</em> – några stora upprop till stöd för Sverige har inte rapporterats från OIC:s medlemsländer.</p>
<p>Inom FN-systemet har OIC envetet drivit igenom resolutioner mot religionskränkningar i syfte att få så många länder som möjligt att införa blasfemilagar. Den första antogs 1999 av FN:s omtvistade människorättsråd UNHRC, ett forum med en lång rad odemokratiska stater, och sex år senare togs frågan för första gången upp i generalförsamlingen. Ärendet föredrogs då av FN-ambassadören för OIC-landet Pakistan, som fått två miljarder kronor av Sverige och vars lagstiftning innehåller dödsstraff för hädelse.</p>
<p>Resolutionen stöddes i omröstningen 2005 av 101 länder, 53 var emot och 20 röstade blankt. En stor majoritet av världens nationer ville alltså begränsa yttrandefriheten. En global anti-västlig allians hade skapats i FN med OIC, Kina, Ryssland och ett antal kristna länder i Afrika och Latinamerika.</p>
<p>Kvartal söker Sveriges bistånds- och utrikeshandelsminister <strong>Johan Forssell</strong> och OIC:s huvudkontor i Saudiarabien för kommentar, i skrivande stund har de inte svarat.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="116037">  <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>
<p>1, https://www.oecd.org/dac/oecd-development-co-operation-peer-reviews-sweden-2019-9f83244b-en.htm</p>
<p>2, https://www.sida.se/publikationer/evaluation-at-sida-annual-report-2021</p>
<p>3, De 721,47 miljoner kronor som gick till Mocambique under 2022 fördelades enligt statistiken på Openaid som:</p>
<p style="font-weight: 400;">244,73 miljoner kronor (33,92 procent) till enskilda organisationer och civila samhället (uppdelat på stöd till internationella (t.ex. Rädda barnen international), inhemska organisationer och sådana som är baserade i givarlandet (till exempel <em>We Effect</em>, som arbetar för att utrota fattigdomen i världen)</p>
<p style="font-weight: 400;">228,86 (31,72 procent) till multilaterala organisationer (majoriteten via FN-organ där Unicef var störst med drygt 46 miljoner kronor.)</p>
<p style="font-weight: 400;">162,34 (22,78 procent) till offentlig sektor (varav Mocambiques offentliga sektor fick 135,6 miljoner, det vill säga 18,79 procent av totalen, och 28,75 miljoner kronor till offentlig sektor i Sverige, till exempel projekt som genomförs av Havs- och vattenmyndigheten och Arbetsförmedlingen.</p>
<p style="font-weight: 400;">51,65 (7,16 procent) till högre utbildning (där största delen går till Universidad Eduardo Mondelane, det största universitetet i Maputo)</p>
<p style="font-weight: 400;">29,1 miljoner kronor (4,03 %) till Mocambiques privata sektor.</p>
<p>Källa: Jan Pettersson, EBA.</p>
<p>4, https://www.fhs.se/download/18.32d29dd2187bd01d5e455265/1682576119173/LVU-kampanjen.pdf</p>
<p>5, https://english.khamenei.ir/news/9963/It-is-the-duty-of-Swedish-govt-to-turn-over-the-criminal-who</p>
</div>
</div>
<div class="author-byline">Lars Åberg är journalist och författare.</p>
<p>Johan Frisk är frilansjournalist och researcher.
</p></div>
</div>
