Därför behandlas inte Israel som andra länder

<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/magnus-norell/">Magnus&nbsp;Norell</a> | 17 februari 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%2Fdarfor-behandlas-inte-israel-som-andra-lander%2F&amp;t=D%C3%A4rf%C3%B6r+behandlas+inte+Israel+som+andra+l%C3%A4nder"    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=D%C3%A4rf%C3%B6r+behandlas+inte+Israel+som+andra+l%C3%A4nder+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdarfor-behandlas-inte-israel-som-andra-lander%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%2Fdarfor-behandlas-inte-israel-som-andra-lander%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Därför behandlas inte Israel som andra länder&body=https://kvartal.se/artiklar/darfor-behandlas-inte-israel-som-andra-lander/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/166937/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%2Fdarfor-behandlas-inte-israel-som-andra-lander%2F&amp;t=D%C3%A4rf%C3%B6r+behandlas+inte+Israel+som+andra+l%C3%A4nder"    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=D%C3%A4rf%C3%B6r+behandlas+inte+Israel+som+andra+l%C3%A4nder+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fdarfor-behandlas-inte-israel-som-andra-lander%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%2Fdarfor-behandlas-inte-israel-som-andra-lander%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Därför behandlas inte Israel som andra länder&body=https://kvartal.se/artiklar/darfor-behandlas-inte-israel-som-andra-lander/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/166937/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 15 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/c1251243-b6ae-4764-a57d-1547d7cf1450"    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-166937">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "166937"></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 ">Sedan Hamas attack på Israel den 7 oktober 2023 har ett av de mest framträdande effekterna varit en enorm ökning av antisemitiska attacker. Det handlar om allt från individuella påhopp på sociala medier, över slagord och plakat med antisemitiskt innehåll vid demonstrationer till direkta fysiska attacker.<sup>1</sup></p>
</div>
<div class="rest-of-article ">
<p>Det finns all anledning att uppmärksamma detta och inte minst det faktum att denna tsunami av antisemitiska attacker (ofta illa dold bakom fraser som antisionism) i hög grad kommer från den politiska vänsterkanten. Vi är vana vid att uppmärksamma antisemitism när den kommer från högerextremister, men betydligt sämre på att erkänna den för närvarande dominerande vänsterradikala och islamistiska varianten.</p>
<p>Tillsammans med antisemitism från vänster kommer också attackerna främst från medborgare med ursprung i den muslimska världen, vilket inte på något sätt är vare sig nytt eller oväntat. Människor som marinerats i en antisemitisk idévärld har självklart med sig mycket i bagaget, och Sverige som samhälle har varit notoriskt dåligt på att med kraft bemöta denna unkna tankevärld. Utan tvekan handlar det om det faktum att dessa invandrare ses som potentiella väljare, och därmed finns en ovilja att gå emot dessa tankegångar med risk för att då förlora dessa potentiella väljare.</p>
<h2>Antisemitism i internationella organisationer</h2>
<p>Vad som är lika oroväckande som de ovan nämnda orsakerna till den <a href="https://www.adl.org/adl-global-100-index-antisemitism">ökande antisemitismen</a> är att den också dykt upp i internationella institutioner skapade för att just motarbeta och angripa övergrepp på människors politiska, religiösa och etniska ursprung.</p>
<p>Några händelser från hösten kan illustrera detta. I november utfärdade Internationella brottmålsdomstolen (ICC) arresteringsorder för Israels premiärminister <strong>Netanyahu</strong> och (tidigare) försvarsminister <strong>Gallant</strong>. Anklagelserna gällde misstanke om krigsbrott.</p>
<p>I december publicerade så Amnesty International (AI) en rapport som anklagar Israel för folkmord i Gaza.</p>
<p>Och i slutet av 2023, bara några månader efter den värsta antisemitiska pogromen mot judar sedan andra världskriget, initierade Sydafrika anklagelser mot Israel för folkmord via Internationella domstolen (ICJ, som är en del av FN).</p>
<p>Alla dessa initiativ är värda att granskas närmare, och det visar sig då att flera märkliga omständigheter föreligger.</p>
<p>Syftet med denna artikel är inte att ta ställning till huruvida krigsbrott har ägt rum eller inte. Det finns inga större militära konflikter under det senaste hundra åren där det inte förekommit brott mot krigets lagar. Men det är en separat fråga, och en fråga som det israeliska juridiska systemet är väl lämpat att ta upp, vilket också redan inträffat.<sup>2</sup></p>
<h2>Sydafrika har anklagat Israel för folkmord förr</h2>
<p>Den 29 december 2023 lämnade Sydafrika in en formell anklagelse till den Haag-baserade Internationella domstolen om att Israel begick folkmord i Gaza, en anklagelse som Sydafrika kom med redan 6 november samma år, alltså mindre än en månad efter Hamas attack mot Israel och <em>innan</em> den israeliska motoffensiven börjat på allvar.</p>
<p>Sydafrikas ANC-ledda regim har en gammal historia av antisemitism och antiisraeliska utspel. De har haft kontakter och samarbete med antiisraeliska och antisemitiska organisationer i åratal.<sup>3</sup> Ur den synpunkten är det kanske inte så förvånande att de, redan innan Israel svarat på Hamas angrepp, kom med anklagelser om folkmord. Ett talande exempel på att detta går långt tillbaka i tiden är det som hände i augusti i Durban 2001, då en storm av anklagelser riktades mot Israel under en FN-konferens om rasism.<sup>4</sup></p>
<p>Sydafrikas förbindelser med Hamas går också tillbaka lång tid, och landets kopplingar till länder som Qatar och Iran (som också stött Hamas under lång tid) går också de tillbaka flera år. Och under den senaste valrörelsen (maj 2024) använde den sittande ANC-regeringen Hamasvänliga, och även rent antisemitiska, slagord i valkampanjen.<sup>5</sup></p>
<p>Men Sydafrikas kampanj mot Israel, i ljuset av den värsta pogromen mot judar sedan andra världskriget, är intressant av flera andra skäl.</p>
<blockquote><p>Bara några dagar efter det att partiet valt att dra i gång processen mot Israel i Internationella domstolen fick ANC en mycket stor donation&#8230;</p></blockquote>
<p>En effekt av Sydafrikas formellt inlämnade anklagelse var att det snabbt blev ett faktum att Internationella domstolen slagit fast att det pågick ett folkmord i Gaza. Men så var det ju inte. Det enda substantiella som Internationella domstolen gjort var att understryka att Israel måste se till att så inte sker. Trots detta har folkmordstanken slagit rot och hörts både på campusdemonstrationer i USA och hos politiker i Västeuropa. I Sverige är det i synnerhet delar av den politiska vänstern samt propalestinska aktivister som fortsatt att kolportera ut denna anklagelse.</p>
<h2>Missnöjet med ANC</h2>
<p>I retoriken har ANC framhållit sitt stöd till palestinierna i allmänhet och därvid inte gjort någon skillnad på det terrorstämplade Hamas och Palestinska myndigheten. Detta skulle då förklara att just Sydafrika driver en så hård kampanj mot Israel, men det finns andra skäl att syna ANC:s motiv.</p>
<p>Vid det senaste valet förlorade ANC för första gången sin parlamentariska majoritet, och missnöjet med regeringen gick inte att ta miste på. Nederlaget visar att många är trötta på ANC:s korruption, misskötsel och ineffektivitet. Det är heller ingen hemlighet att ANC:s partiledning är synnerligen korrupt. Det har försnillats pengar under lång tid, vilket förklarar mycket av valförlusten i våras. ANC har således inte bara gjort moralisk, utan även ekonomisk bankrutt. Och det är här som det blir extra intressant med den formella anklagelsen mot Israel.</p>
<p>Bara några dagar efter det att partiet valt att dra i gång processen mot Israel i Internationella domstolen fick ANC en mycket stor donation som löste mycket av den prekära ekonomiska situationen.<sup>6</sup> ANC vägrar att berätta varifrån denna donation kom, men besvärande nog för ANC finns det starka indicier på att det var Qatar och Iran som stod för pengarna.<sup>7</sup> Det är väl känt att Sydafrika inlett ett strategiskt samarbete med Iran, och att regimen i Teheran använder Sydafrika som ett sätt att runda de ekonomiska sanktionerna som landet utsatts för. Dessutom träffade ANC-ministrar representanter för Qatar, Iran och Hamas strax innan processen mot Israel inleddes.</p>
<p>Det är inte första gången som skurkstater använder internationella institutioner för att stärka sin egen position eller för att underminera västvärldens demokratier. <strong>Putins</strong> Ryssland och Kinas missbruk av Interpol är välkända exempel. Så om ANC och Sydafrika använder liknande grepp borde det inte förvåna någon.<sup>8</sup></p>
<p>Det är värt att understryka att varje process vid Internationella domstolen tar lång tid och kostar mycket pengar. Detta fall beräknas kosta minst 10 miljoner dollar bara initialt. Pengar som ANC och Sydafrika inte har såvida ingen annan betalar, vilket alltså skett här. På så sätt blir folkmordsanklagelser något som kan säljas och köpas om priset är det rätta.</p>
<p>Något annat som styrker rapporten om att Sydafrika köpts till att missbruka Internationella domstolen är det faktum att anmälan inte styrktes av några som helst bevis för att folkmord begåtts. Men det visar Sydafrikas och ANC:s brist på moral och en utbredd antisemitism, en antisemitism som snabbt anammades av många andra.</p>
<h2>Internationella brottmålsdomstolen ska agera när inga andra medel finns</h2>
<p>I november 2024 (processen började i maj 2024 med att chefsåklagare <strong>Karim Khan</strong> efterfrågade en arresteringsorder) utfärdade Internationella brottsmålsdomstolen arresteringsorder för premiärminister Netanyahu och (dåvarande) försvarsminister Gallant. Utfärdandet hade föregåtts av diverse juridiska och politiska manövrer från Internationella brottmålsdomstolens chefsåklagares sida.</p>
<p>Khans handläggande av ärendet lämnar en hel del övrigt att önska och riskerar att försämra Internationella brottsmålsdomstolens möjligheter att agera i fall där det verkligen är motiverat.</p>
<p>Till att börja med är det en grundläggande princip att Internationella brottsmålsdomstolen ska agera när inga andra medel står till buds. Det vill säga att när ett land varken har medel eller vilja att självt utreda misstänkta brott mot krigets lagar<sup>9</sup> eller brott mot internationell humanitär rätt<sup>10</sup> kan Internationella brottsmålsdomstolen kliva in. Det är inte fallet i Israel, som har ett robust, självständigt och från de politiska aktörerna oavhängigt juridiskt system för att utreda misstänkta krigsbrott. Vid flera tillfällen har också det skett under kriget mot Hamas, vilket inte Internationella brottsmålsdomstolen överhuvudtaget brytt sig om.<sup>11</sup> Därvid har alltså chefsåklagare Khan medvetet åsidosatt en av den egna institutionens grundläggande principer.</p>
<p>Som om det inte var nog; ytterligare en viktig princip för att säkra en rättvis och oantastlig process är att den anklagade har rätt att själv utreda och/eller svara på anklagelserna innan något beslut om arresteringsorder fattas. Så har inte heller skett här. Tvärtom förvägrades Israel information om anklagelserna och kunde således inte bemöta dem och – som statueras i Internationella brottsmålsdomstolens grunddokument, Romstadgan – få nödvändig information om anklagelserna för att utreda och, om bevis föreligger, döma i fallet.<sup>12</sup></p>
<p>Enligt paragraf 18 i Romstadgan måste åklagaren informera landet i fråga om att en undersökning pågår och på vilka grunder. Landet har sedan en månad på sig att visa att en egen/egna undersökningar pågår. Men Israel informerades inte innan Khan satte i gång, vilket bland annat USA:s dåvarande utrikesminister <strong>Antony Blinken</strong> var snabb med att påpeka. USA hör också till de länder som kritiserat Khan och Internationella brottsmålsdomstolen för handläggningen.</p>
<p>Dessutom bryter Khan och Internationella brottsmålsdomstolen mot den egna så kallade komplementaritetsprincipen (<em>complementarity</em>) som säger att ICC inte kan åtala alls om landet i fråga självt hanterar misstänkta fall, vilket Israel alltså gör.</p>
<p>Det ska återigen understrykas att Israel besitter alla de nödvändiga lagar och juridiska medel som betecknar ett demokratiskt och fritt samhälle.</p>
<h2>En cirkus för att förfölja Israel</h2>
<p>Förutom att Internationella brottsmålsdomstolen frångått sin egen princip om att vara en sista utväg för misstänkta brott mot mänskligheten så är det tveksamt om Internationella brottsmålsdomstolen ens har någon jurisdiktion alls i detta fall. Enligt Osloavtalet, som reglerar förhållandet mellan Israel och Palestinska myndigheten, har de ingen sådan jurisdiktion och kan därför inte delegera till Internationella brottsmålsdomstolen. Israel är heller inte bunden av Internationella brottsmålsdomstolen eftersom man inte undertecknat dess styrdokument.</p>
<p>Slutligen, i samband med arresteringsorderna mot Netanyahu och Gallant utfärdades en arresteringsorder mot <strong>Mohammad Deif</strong>, Hamas militära chef. Men Deif var då redan dödad, och i ljuset av detta framstår hela denna cirkus som ett sätt att framför allt förfölja Israel.</p>
<p>Allt detta är tämligen grova juridiska övertramp och skadar Internationella brottsmålsdomstolen som institution. Det råder knappast brist på länder som styrs med brutala metoder och som helt saknar säkra och rättvisa juridiska institutioner. Det räcker med att nämna Syriens förra diktator <strong>Assad</strong>, som använt kemiska stridsmedel mot sin egen befolkning<sup>13</sup>, Myanmars styrande militärjunta med general <strong>Min Aung Hlaing</strong>, som förföljer den muslimska Rohingyaminoriteten i landet<sup>14</sup>, eller Sudans brutala krigsherre <strong>Mohamad Hamdan Dagalo</strong>, som bedriver etnisk rensning i Sudan.<sup>15</sup> Ingen av dessa herrar har blivit föremål för Internationella brottsmålsdomstolens intresse.</p>
<p>Både Internationella domstolen och Internationella brottsmålsdomstolen har FN-koppling. Internationella domstolen är ett FN-organ, och Internationella brottsmålsdomstolen är nominellt självständig men godkänns av generalförsamlingen. Och att FN ansträngt sig genom åren att sila mygg och svälja kameler är ingen nyhet.<sup>16,17</sup></p>
<p>Genom sitt agerande i den här konflikten – där Hamas väldigt tydligt illustrerat sina brott mot mänskligheten – har Khan gjort både sin institution och det palestinska folket en björntjänst.</p>
<h2>Amnesty International</h2>
<p>I december 2024 släppte Amnesty International en rapport som anklagar Israel för folkmord i Gaza.<sup>18</sup> Rapporten kritiserades tämligen omgående (av bland annat USA:s regering) för besvärande brister och felaktigheter.<sup>19</sup> Kritiken handlar om allt från brist på bevis och undermålig metodologi till påvisbara fördomar mot Israel.<sup>20</sup> Framför allt riktade kritikerna in sig på det faktum att Amnesty, i sin slutsats att Israels agerande i Gaza är att likställa med folkmord, helt bortser från två grundläggande principer som måste uppfyllas för att en anklagelse om folkmord ska hålla.</p>
<p>Dels handlar det om att det måste föreligga ett medvetet mål hos beslutsfattarna (<em>special intent</em>) att helt eller delvis förstöra en grupp. Dels handlar det om principen att folkmord är den enda möjliga slutsatsen baserat på fakta (<em>the only possible inference</em>). Dessa båda huvudprinciper lyser med sin frånvaro i rapporten och innebär att – tillsammans med andra metod- och faktafel – hela rapporten fallerar.</p>
<p>Att det krig som Hamas startade med sitt angrepp på Israel den 7 oktober 2023 har inneburit ett stort lidande med många dödsoffer i Gaza är uppenbart. Men med tanke på Hamas medvetna uppbyggnad där de militära resurserna och infrastrukturen medvetet läggs bland civil infrastruktur (som till exempel skolor och sjukhus) hade Israel knappast något alternativ till att systematiskt förstöra denna infrastruktur. Att det innebär stor förödelse var ju också del av Hamas plan att få Israel att framstå som den angripande parten. Som ledare för Hamas själva påpekat var det enormt utbyggda tunnel- och bunkersystemet endast avsett för de egna miliserna och inget skydd för civilbefolkningen.<sup>21</sup></p>
<p>Att Israel dessutom, under hela kriget, systematiskt varnat civilbefolkningen före angrepp, designat så kallat ”säkra zoner”, samt tillåtit förnödenheter in i Gaza visar tydligt att Israel, tvärtemot Amnestys rapport, gått väldigt långt för att, så långt det går, undvika civila offer. Att det inte alltid lyckats och att det absolut kan ha förekommit brott mot mänskligheten förändrar inte den bilden och visar tydligt på den märkliga anklagelsen som Amnestys rapport uppvisar.<sup>22</sup></p>
<p>Att en organisation som Amnesty, så öppet och med så lite underlag, ligger bakom en sådan allvarlig anklagelse om folkmord är naturligtvis mycket besvärande. I synnerhet som det både sänker den egna trovärdigheten, samtidigt som verkligt skyldiga går fria. Det finns miljoner människor som skulle behöva en röst som Amnesy till stöd mot brutala och auktoritära regimer.</p>
<p>Så vad beror då detta på? Och vad betyder det att tre stora internationella organisationer så flagrant bryter mot, eller bortser från, de egna principerna?</p>
<p>Till att börja med passar beteendet vid dessa internationella institutioner väl in i det mönster av antisemitiska angrepp som ökat lavinartat sedan oktober 2023. Bara i Sverige ökade antalet hatbrott (som anmäldes, siffran kan således vara högre) med 450 procent på bara ett par månader jämfört med hösten 2022.<sup>23</sup> Liksom i andra länder där liknande ökningar skett<sup>24</sup> har det sedan flera år utvecklats vad Segerstedtinstitutet kallar en ”israelisering” av antisemitismen.<sup>25</sup> Det innebär att konflikten mellan israeler och palestinier påverkat antisemitismens uttryck i högre grad än tidigare. Det innebär att antisemitismen ofta kläs i ord som antisionism. Till detta kan läggas det faktum att fler människor demonstrerade <em>för</em> Hamas brutala våld än de som demonstrerade <em>mot</em> Hamas exempellösa våld.<sup>26</sup> Vad detta visar är att det finns ett avgrundsdjup mellan dem som hyllar mord på judar i och utanför Israel, och dem som utan tvekan fördömer samma attacker.</p>
<blockquote><p>Lika allvarligt är naturligtvis att denna koncentration på Israel spelar auktoritära och brutala regimer rätt i händerna.</p></blockquote>
<p>Dessa trender och ökningar beror till stor del på den stora invandring från länder i MENA-regionen, där antisemitismen sedan länge utgör en grundläggande del av vad individer får med sig från tidig ålder.<sup>27</sup> Denna ”vardagliga” antisemitism sträcker sig från demonstrationer och våld mot förbipasserande,<sup>28</sup> över angrepp mot enskilda forskare,<sup>29</sup> till hotfulla mejl riktade till institutioner som har samarbete med israeliska dito, som till exempel Göteborgs universitet.<sup>30</sup></p>
<p>Ett av de mer groteska exemplen på denna vardagliga antisemitism var nedslitandet av affischer uppsatta för att uppmärksamma den gisslan (250 personer) som Hamas förde med sig till Gaza.</p>
<p>Sammantaget visar detta på den spridning och omfattning som antisemitismen har även i det, som man hoppades, upplysta demokratiska Väst.</p>
<p>I ljuset av det ovan beskrivna blir agerandet hos dessa tre stora organisationer kanske inte så märkligt, utan snarare en del av ett större skeende. Konsekvenserna blir hursomhelst att förtroendet för dessa internationella institutioner försvagas och att ett misstroende mot dem ökar.</p>
<p>Lika allvarligt är naturligtvis att denna koncentration på Israel spelar auktoritära och brutala regimer rätt i händerna. Det blir enkelt för till exempel Ryssland, Kina och Iran att peka finger åt ett hycklande Väst och att institutioner som Internationella brottmålsdomstolen, Internationella domstolen och Amnesty inte behöver tas på allvar.</p>
<p>Sedan Hamas attackerade Israel har vi blivit varse hur utbredd och, på många håll, salongsfähig antisemitismen har blivit. Det öppna och oblyga hatet mot Israel och judar i allmänhet bör vara en väckarklocka och leda till att vi tar det hotet på allvar. Det bör också stå klart att när detta rasistiska hat även har infiltrerat internationella institutioner – uppbyggda för att skydda individer för just sådana övergrepp – är det hög tid att agera.<a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="166937">  <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>Värt att påpeka här är att trots ymnigt förekommande antisemitiska slagord och sånger vid demonstrationer mot Israel och judar, har ingen dömts, eller ens åtalats, för hets mot folkgrupp. Och detta trots att det finns många fall där gränsen för åtal passerats. Se t.ex.: Svd, 9 januari 2025, sid. 7</li>
<li><a href="https://www.haaretz.com/israel-news/2024-12-13/ty-article/.premium/israels-top-military-lawyer-blocking-gaza-war-crime-probes-tarnishes-all-idf-soldiers/00000193-c081-d884-a3fb-e2d1d2160000">Israel&#8217;s Top Military Lawyer: Blocking Gaza War Crime Probes Tarnishes All IDF Soldiers &#8211; Israel News &#8211; Haaretz.com</a></li>
<li>https://www.sazf.org/resources/durban/durban-01-memories-from-frontline</li>
<li>https://www.youtube.com/watch?v=MoGAvhb7wiA</li>
<li>Farouk Chothia, “The ANC Hopes to Conquer But Will It Struggle in South Africa Poll?,” BBC News, 26 maj 2024, https://www.bbc.com/news/articles/cg33yyl4mzzo.</li>
<li><a href="https://www.ynetnews.com/article/h1msjxlfje">Iran and Qatar behind South Africa’s World Court case against Israel, report claims</a></li>
<li><a href="https://x.com/ISGAP1/status/1857427073398194543">ISGAP på X: ”The South African ANC Government&#8217;s Dangerous Alliances with Iran, Qatar and Hamas: Report Reveals How South African ANC ICJ Bid Against Israel is Part of a Broader Strategy to Advance the Interests of Terror-Linked States, Undermining Global Security and Democratic Governments” / X</a></li>
<li><a href="https://www.euronews.com/2023/04/06/russia-and-chinas-abuse-of-red-notices-could-break-interpol-beyond-repair">Russia and China&#8217;s abuse of Red Notices could break Interpol beyond repair | Euronews</a></li>
<li>https://www.icrc.org/sites/default/files/external/doc/en/assets/files/other/law1_final.pdf</li>
<li>https://civil-protection-humanitarian-aid.ec.europa.eu/what/humanitarian-aid/international-humanitarian-law_en</li>
<li><a href="https://www.haaretz.com/israel-news/2024-12-13/ty-article/.premium/israels-top-military-lawyer-blocking-gaza-war-crime-probes-tarnishes-all-idf-soldiers/00000193-c081-d884-a3fb-e2d1d2160000">Israel&#8217;s Top Military Lawyer: Blocking Gaza War Crime Probes Tarnishes All IDF Soldiers &#8211; Israel News &#8211; Haaretz.com</a></li>
<li>https://www.timesofisrael.com/israel-claims-icc-prosecutor-denying-countrys-right-to-probe-gaza-war-allegations/</li>
<li><a href="https://www.washingtonpost.com/opinions/2023/08/23/syria-chemical-weapons-accountability/">Opinion | Syria must be held to account for chemical weapons &#8211; The Washington Post</a></li>
<li><a href="https://www.amnesty.org/en/latest/news/2024/08/myanmar-new-attacks-against-rohingya-a-disturbing-echo-of-2017-mass-violence/">Myanmar: New attacks against Rohingya a disturbing echo of 2017 mass violence &#8211; Amnesty International</a></li>
<li><a href="https://www.washingtonpost.com/opinions/2023/08/29/sudan-darfur-genocide/">Opinion | In Sudan, a Darfur genocide unfolds — again &#8211; The Washington Post</a></li>
<li>https://www.jstor.org/stable/43554877</li>
<li>https://www.fdd.org/analysis/2023/11/08/united-nations-bigotry-towards-israel-unrwa-anti-semitism-poisons-palestinian-youth/</li>
<li><a href="https://www.amnesty.org/en/latest/news/2024/12/amnesty-international-concludes-israel-is-committing-genocide-against-palestinians-in-gaza/">Amnesty concludes Israel is committing genocide in Gaza</a></li>
<li><a href="https://www.haaretz.com/israel-news/2024-12-05/ty-article/.premium/amnesty-israel-rejects-biased-genocide-report-by-international-organization/00000193-95c0-d408-a7d3-bfd92c6d0001">&#8217;Predetermined Conclusion&#8217;: Amnesty Israel Rejects Gaza Genocide Report by Amnesty International &#8211; Israel News &#8211; Haaretz.com</a></li>
<li><a href="https://www.amnesty.org.il/2024/12/08/the-alternative-hypothesis-to-israeli-intent-to-commit-genocide/">The alternative hypothesis to Israeli intent to commit genocide &#8211; אמנסטי אינטרנשיונל ישראל</a></li>
<li>Se till exempel: <a href="https://kvartal.se/artiklar/hamas-ledarens-ord-till-mig-vi-ska-forinta-israel/">https://kvartal.se/artiklar/hamas-ledarens-ord-till-mig-vi-ska-forinta-israel/</a> ; <a href="https://bulletin.nu/norell-brutaliteten-kan-vara-borjan-till-hamas-undergang">https://bulletin.nu/norell-brutaliteten-kan-vara-borjan-till-hamas-undergang</a> ; <a href="https://www.fokus.se/aktuellt/darfor-bygger-hamas-tunnlar-i-stallet-for-skyddsrum/">https://www.fokus.se/aktuellt/darfor-bygger-hamas-tunnlar-i-stallet-for-skyddsrum/</a> ; <a href="https://podcasts.apple.com/us/podcast/the-brutality-of-war-with-yossi-klein-halevi/id1539292794?i=1000682091223">The Brutality of War &#8211; with Yo &#8211; Call Me Back &#8211; with Dan Senor &#8211; Apple Podcasts</a></li>
<li><a href="https://www.haaretz.com/israel-news/2024-12-13/ty-article/.premium/israels-top-military-lawyer-blocking-gaza-war-crime-probes-tarnishes-all-idf-soldiers/00000193-c081-d884-a3fb-e2d1d2160000">Israel&#8217;s Top Military Lawyer: Blocking Gaza War Crime Probes Tarnishes All IDF Soldiers &#8211; Israel News &#8211; Haaretz.com</a></li>
<li>https://www.gu.se/sites/default/files/2024-09/Antisemitism-i-Sverige-efter-7-oktober.pdf</li>
<li>https://www.adl.org/resources/press-release/over-10000-antisemitic-incidents-recorded-us-oct-7-2023-according-adl?gad_source=1&amp;gclid=EAIaIQobChMI__uqrofmigMVolyRBR3euShEEAAYASAAEgLuDvD_BwE&amp;gclsrc=aw.ds</li>
<li><a href="https://www.gu.se/sites/default/files/2024-09/Antisemitism-i-Sverige-efter-7-oktober.pdf">https://www.gu.se/sites/default/files/2024-09/Antisemitism-i-Sverige-efter-7-oktober.pdf</a>. Sid 2</li>
<li>https://www.axess.se/artiklar/ett-moraliskt-haveri/</li>
<li><a href="https://www.gu.se/sites/default/files/2024-09/Antisemitism-i-Sverige-efter-7-oktober.pdf">https://www.gu.se/sites/default/files/2024-09/Antisemitism-i-Sverige-efter-7-oktober.pdf</a>. Sid 3</li>
<li>https://www.fokus.se/kultur/sten-widmalm-demonstranterna-utfardar-fotoforbud-for-andra/</li>
<li>https://www.gp.se/kultur/kulturdebatt/attacken-mot-anders-persson-ar-en-attack-mot-demokratin.4b3af3ba-6641-47dc-9503-55a776f0d10a</li>
<li><a href="https://www.facebook.com/share/p/19XzuSiyUv/">https://www.facebook.com/share/p/19XzuSiyUv/</a></li>
</ol>
</div>
</div>
<div class="author-byline">Magnus Norell är statsvetare samt freds- och konfliktforskare.
</div>
</div>
