”Lundin Oil utsattes för desinformationskampanj”

<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-107499"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="107499" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfbHVuZGluX29pbF91dHNhdHRlc19mb3JfZGVzaW5mb3JtYXRpb25za2FtcGFuai5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvbHVuZGluLW9pbC11dHNhdHRlcy1mb3ItZGVzaW5mb3JtYXRpb25za2FtcGFuai5tcDM=">  <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/bengt-g-nilsson/">Bengt G&nbsp;Nilsson</a> | 21 september 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%2Flundin-oil-utsattes-for-desinformationskampanj%2F&amp;t=%E2%80%9DLundin+Oil+utsattes+f%C3%B6r+desinformationskampanj%E2%80%9D"    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=%E2%80%9DLundin+Oil+utsattes+f%C3%B6r+desinformationskampanj%E2%80%9D+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Flundin-oil-utsattes-for-desinformationskampanj%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%2Flundin-oil-utsattes-for-desinformationskampanj%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=”Lundin Oil utsattes för desinformationskampanj”&body=https://kvartal.se/artiklar/lundin-oil-utsattes-for-desinformationskampanj/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/107499/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/107499/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="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%2Flundin-oil-utsattes-for-desinformationskampanj%2F&amp;t=%E2%80%9DLundin+Oil+utsattes+f%C3%B6r+desinformationskampanj%E2%80%9D"    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=%E2%80%9DLundin+Oil+utsattes+f%C3%B6r+desinformationskampanj%E2%80%9D+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Flundin-oil-utsattes-for-desinformationskampanj%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%2Flundin-oil-utsattes-for-desinformationskampanj%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=”Lundin Oil utsattes för desinformationskampanj”&body=https://kvartal.se/artiklar/lundin-oil-utsattes-for-desinformationskampanj/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/107499/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/107499/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/lundin-oil-utsattes-for-desinformationskampanj/?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 8 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/107499"    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-107499">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "107499"></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 ">I december 1999 vandrade jag med min filmutrustning i knappt två veckor med gerillan <em>Sudan People&#8217;s Liberation Army</em>, SPLA, i Nubabergen i Sudan. Gerillan befann sig i krig med regeringen i Khartoum och hade kontroll över större delen av bergsområdet.</p>
</div>
<div class="rest-of-article ">
<p>Jag sov ofta under bar himmel men inkvarterades ibland i en hydda av enklaste slag. En natt vaknade jag av ett ljud som inte borde finnas där. Det distinkta knattret från en liten tvåtaktsmotor. Nyfiken steg jag upp och gick ut i mörkret. Motorn visade sig vara en elgenerator och en bit bort i byn såg jag ett ljussken. Det kom från en filmduk.</p>
<p>Byns hela befolkning satt där på marken och tittade på en Jesusfilm med arabiskt tal. Den handlade om Frälsarens mirakel.</p>
<h2>Kristna missionärer</h2>
<p>Jag fick veta att det var en grupp kristna aktivister som vandrade genom Nubabergen och visade Jesusfilmen för muslimska bybor som naturligtvis var extremt svältfödda på underhållning. För många var det första gången i livet de fick se en film.</p>
<p>– Deras filmvisning är mycket uppskattad, vi lär oss hur världen utanför Nubabergen ser ut, sa en av gerillasoldaterna.</p>
<p>Det var gruppen <em>Frontline Fellowship</em>. De var i Nubabergen runt millennieskiftet för att vinna proselyter.</p>
<p>Rörelsen startades av pastor <strong>Peter Hammond</strong> som tjänstgjorde i Sydafrikas armé under apartheidtiden. På rörelsens hemsida presenteras han som en hängiven försvarare av kristna värden, besatt av att skydda förföljda kristna. Rörelsens namn har en militaristisk klang. Det är ingen slump. <em>Frontline Fellowship</em> var ett brödraskap vid kristenhetens frontlinje.</p>
<p>Hammond samarbetade nära med <em>New Sudan Council of Churches</em>, Nya Sudans kristna råd. Begreppet ”Nya Sudan” signalerade att det var en skapelse av SPLA-gerillan.</p>
<figure id="attachment_107524" aria-describedby="caption-attachment-107524" style="width: 2560px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-107524 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/Jag-o-barn-scaled.jpg" alt="kvartal" width="2560" height="1705" data-wp-pid="107524" srcset="https://kvartal.se/wp-content/uploads/2023/09/Jag-o-barn-scaled.jpg 2560w, https://kvartal.se/wp-content/uploads/2023/09/Jag-o-barn-1536x1023.jpg 1536w, https://kvartal.se/wp-content/uploads/2023/09/Jag-o-barn-2048x1364.jpg 2048w, https://kvartal.se/wp-content/uploads/2023/09/Jag-o-barn-600x400.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/Jag-o-barn-300x200.jpg 300w, https://kvartal.se/wp-content/uploads/2023/09/Jag-o-barn-768x511.jpg 768w" sizes="(max-width: 2560px) 100vw, 2560px" /><figcaption id="caption-attachment-107524" class="wp-caption-text">Artikelförfattaren Bengt G Nilsson på plats i Afrika för cirka 20 år sedan. Foto: Heldur Netocny.</figcaption></figure>
<p>”Det här”, skriver Hammond i boken <em>Faith under fire in Sudan</em>, ”är den bortglömda frontlinjen för kampen om tro och frihet. Sudan är det mest strategiska landet för mission. Sudan är det enda landet i den muslimska Mellanöstern med miljoner väckelsekristna. [I södern, min anm.] Muslimer har kommit till Kristus i tusental. Sudan var det sista landet som islamiserades. Med Guds försyn kan det bli det första muslimska landet att vinnas tillbaka till Kristus!”</p>
<p>Han skriver att kyrkan nu måste samla sig för att blockera muslimer, hinduer och buddister i Nordafrika och Asien mellan den tionde och fyrtionde breddgraden.</p>
<h2>Ett önskvärt bibelbälte</h2>
<p>År 1990 myntades begreppet ”10/40 window” av en kristen missionär vid namn <strong>Luis Bush</strong>. Tesen lyder att mellan den tionde och fyrtionde breddgraden norr om ekvatorn, i ett bälte runt jorden, finns de länder där kristen frälsning är som mest angelägen. Det är länder där andra religioner, främst islam, dominerar. Ordet <em>window</em> syftar på det engelska uttrycket <em>window of opportunity</em>, alltså en tillfällig möjlighet som inte kommer att vara för evigt, ett fönster som står öppet nu men som kan komma att stängas snart om de kristna inte skyndar på med sin frälsning. Bland väckelsekristna är det här en helig uppgift. I Afrika är det en fråga som upptar miljoner kristna, och även muslimer som känner sig hotade av 10/40-window-doktrinen.</p>
<p>Gränsen mellan norra och södra Sudan som 2011 blev nationsgräns råkar händelsevis löpa utmed den tionde breddgraden. Den latituden markerar en skiljelinje med både religiös och politisk betydelse. Det här är en fråga som rönt liten uppmärksamhet, men som hade en mycket stor betydelse under det andra sudanesiska inbördeskriget.</p>
<blockquote><p>För väckelsekristna runt om i världen, däremot, var det en ren krigsförklaring&#8230;</p></blockquote>
<p>I Sudan uppstod en unik situation då gerillan SPLA beslutade sig för att göra kristendomen till en del av sitt varumärke. Det skedde i opposition mot Khartoums uttalade avsikt att islamisera södern, men det var också ett taktiskt drag för att knyta till sig utländskt stöd. SPLA hade länge en förment socialistisk profil vilket ansågs nödvändigt för att slå vakt om stöd från kommunistjuntan i Etiopien, som i sin tur backades upp av Sovjetunionen. I den kontexten fanns det inte plats för gudsdyrkan.</p>
<p>Men när både juntan och Sovjetimperiet kollapsade 1991 behövde inte SPLA längre låtsas vara en marxistisk rörelse och <em>New Sudan Council of Churches,</em> som året innan hade fått gerillans välsignelse, kunde nu operera fritt.</p>
<h2>En krigsförklaring</h2>
<p>När <a href="https://www.svt.se/nyheter/inrikes/nu-inleds-rattegangen-mot-lundin-oil-topparna">Lundin Oil</a> kom till Sudan 1997 för att leta efter olja slog de sig ned i byn Rubkona i södern. Den ligger praktiskt taget mitt på den tionde breddgraden, men sannolikt tänkte ingen i bolaget närmare på det. För väckelsekristna runt om i världen, däremot, var det en ren krigsförklaring – de utländska oljebolagen i Sudan skulle tjäna pengar åt regeringen i Khartoum. President <strong>Omar Bashirs</strong> närmaste man <strong>Hassan Turabi</strong> var en vår tids allra främsta islamistledare.</p>
<p>Det var inte bara <em>New Sudan Council of Churches</em> som kunde operera fritt i SPLA:s hägn. Det kunde även mängder av utländska kristna frälsarrörelser. Den ovan nämnda <em>Frontline Fellowship</em> tillsammans med <em>Samaritan&#8217;s Purse</em>, <em>Voice of the Martyrs</em>, <em>Safe Harbor</em> och många fler. De chartrade flygplan och levererade biblar till krigsområden i södra Sudan, de arbetade för högtryck i medvetande om att detta möjligheternas fönster inte skulle vara öppet för evigt.</p>
<p>Frågan var då vad de kristna frälsarrörelserna kunde göra för att stoppa oljeutvinningen. Deras övergripande mål var ju att stötta gerillan SPLA och motarbeta islamisterna i Khartoum. År 2001 kom svaret på den frågan. Då publicerade den brittiska organisationen <em>Christian Aid</em> en <a href="https://reliefweb.int/report/sudan/scorched-earth-oil-and-war-sudan">rapport</a> med namnet <em>The Scorched Earth</em>, den brända jorden. Det var en anklagelseakt riktad först och främst mot Lundin Oil.</p>
<p>”Ögonvittnen berättar att regeringsstyrkor brutalt bereder väg för oljan på en ständigt växande yta. I ett område i östra övre Nilen där ett nytt konsortium inledde prospektering i mars 2001 har 48 byar bränts ned och 55 000 personer fördrivits de senaste 12 månaderna. Utmed en ny väg i ett europeiskt oljebolags koncessionsområde finns, enligt ett ögonvittne, inte en enda by kvar.”</p>
<p>Av taktiska skäl nämndes inte Lundin Oil vid namn, det hade kunnat leda till en stämning för förtal. Men de som läste rapporten förstod mycket väl vilket bolag det handlade om. Det fanns bara en ”ny väg i ett europeiskt oljebolags koncessionsområde”, och den hade byggts av Lundin.</p>
<h2>Gripet ur luften</h2>
<p>Eftersom jag hade varit där både före och efter vägbygget, flugit helikopter över området och åkt bil på vägen kunde jag konstatera att Christian Aids påstående var helt gripet ur luften.</p>
<p>Det enda som var sant var att 55 000 människor hade fördrivits, dock från andra delar av delstaten. Faktum var att det rörde sig om ännu fler och de hade tagit sin tillflykt till Rubkona där Lundin Oil hade sitt läger. Där fanns även den sudanesiska arméns kaserner. Och enligt <em>Christian Aid</em> var det den armén som hade mördat och fördrivit alla flyende. Skulle alltså de våldsutsatta människorna söka sig till förövarna för att få skydd?</p>
<blockquote><p>Ett tydligt vänsterkristet narrativ hade utvecklats.</p></blockquote>
<p><em>Christian Aid</em> var en av ett femtiotal kristna grupper som ingick i nätverket <em>European Coalition on Oil</em> <em>in Sudan</em>, ECOS. De samarbetade med den SPLA-anknutna <em>New Sudan Council of Churches</em> med målet att stärka gerillan och försvaga Khartoumregeringen. År 2010 publicerade ECOS en <a href="https://www.ecosonline.org/reports/2010/UNPAID_DEBT_fullreportweb.pdf">rapport</a> betitlad <em>Unpaid debt</em>, obetald skuld. Där fördjupade de anklagelserna mot Lundin Oil.</p>
<p>Ett tydligt vänsterkristet narrativ hade utvecklats. I korthet lydde det att regeringsarmén tillsammans med allierade milisgrupper gick fram över delstaten, skövlade och härjade, brände byar och mördade människor. Allt i syfte att göra det möjligt för Lundin Oil att leta efter olja.</p>
<figure id="attachment_107527" aria-describedby="caption-attachment-107527" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-107527 size-full" src="https://kvartal.se/wp-content/uploads/2023/09/Barnsoldat_01.jpg" alt="" width="1024" height="576" data-wp-pid="107527" srcset="https://kvartal.se/wp-content/uploads/2023/09/Barnsoldat_01.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/09/Barnsoldat_01-600x338.jpg 600w, https://kvartal.se/wp-content/uploads/2023/09/Barnsoldat_01-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2023/09/Barnsoldat_01-768x432.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-107527" class="wp-caption-text">Barnsoldater i Sudan. Foto Bengt G Nilsson.</figcaption></figure>
<p>Eftersom jag hade varit där visste jag att det inte var så kriget bedrevs. Kriget började innan Lundin kom dit, det pågick medan Lundin var där och det fortsatte efter det att Lundin Oil hade lämnat landet. Men nu var det inte sanningen de kristna grupperna var ute efter. De ville hjälpa SPLA att vinna kriget och det kunde bara ske genom att demonisera Lundin Oil och därigenom skada dess <em>corporate reputation</em>, försämra aktievärdet. Och det lyckades. Lundin gav upp 2003 och det gjorde även det kanadensiska bolaget Talisman. Kvar blev kinesiska bolag som var helt resistenta mot påtryckningar och krav på etiskt uppförande.</p>
<p>Det var inte bara europeiska vänsterkristna organisationer som samlade sig i kampen mot oljebolagen. I USA växte en folkrörelse fram, driven av kristna aktivister som engagerade allt från kända skådespelare till affischnamn som <strong>Coretta Scott King</strong>, änka efter <strong>Martin Luther King</strong>.</p>
<h2>En viktig amerikansk prioritet</h2>
<p>Det var den väckelsekristne <strong>Franklin Graham</strong>, son till den berömda predikanten <strong>Billy Graham</strong>, som svor in <strong>George W. Bush</strong> till president 2001. Franklin Graham är grundare av den ovan nämnda evangelikala rörelsen <em>Samaritan&#8217;s Purse</em>. Relationen mellan de två männen resulterade i att den djupt troende president Bush utnämnde Sudan till sin viktigaste utrikespolitiska prioritet.</p>
<p>Fyra år senare hade USA tvingat fram ett fredsavtal mellan Khartoum och SPLA, som utmynnade i att Sudan delades, Khartoum miste nästan alla sina oljetillgångar och SPLA bildade regering i det nya landet Sydsudan.</p>
<p>Berättelsen om inbördeskriget i Sudan är alltså berättelsen om hur amerikanska högerkristna och europeiska vänsterkristna tillsammans tvingade bort de västerländska oljebolagen, försvagade Khartoumregeringen och stärkte SPLA.</p>
<p>Den svenske åklagaren som inledde sin förundersökning 2010 gjorde det efter att ha läst rapporten från ECOS.</p>
<p>Den är enligt min uppfattning ett avancerat falsarium innehållande anklagelser som inte går att styrka, ofta formulerade av anonyma vittnen från platser som inte namnges. Kriget i Sudan var en tragedi och jag tycker det är mycket osmakligt att verkliga krigsoffer ska förvandlas till statister i en pjäs som handlar om att smutskasta ett oljebolag.</p>
<p>Anklagelserna mot Lundin Oil har från allra första stund haft formen av en massiv desinformationskampanj. De svenska åklagarna har utsatts för en försåtlig påverkansoperation som de uppenbarligen inte har varit medvetna om. Allt de kristna grupperna gjorde syftade till att stärka SPLA och försvaga Khartoum. Men av den problematiken syns inte ett spår i åklagarnas material.</p>
<p>En naiv övertro på kristna gruppers oförvitlighet ledde till att de vinklade skildringarna av kriget uppfattades som fakta.</p>
<div class="author-byline">Bengt G Nilsson är journalist och författare, aktuell med boken ”Lundin Oil och sanningen om södra Sudan”.
</div>
</div>
