I korthet
Extremhögern saknar kvinnor.
De menar att kvinnan är vek, svag, passiv och rent instinktivt följer alfahannen.
En stor farhåga för rasnationalisterna är att vita människor ska utrotas. Därför är kvinnan viktig som barnaföderska.
Alternativhögern försöker tukta kvinnor bl.a. genom en nätbaserad sedlighetspolis shariastyle. Men resultatet är klent.
Kvinnan som länge satts på piedestal har alltmer kommit att anta rollen av en femtekolonnare.
När jag 2017 och 2018 infiltrerade svensk extremhöger1, eller mer specifikt de kretsar som själva gärna går under namnet ”alternativhögern”, så var det förhållandevis enkelt.
<div class="kvartal-meta clearfix" style="color: ">Av <a href="https://kvartal.se/medverkande/jenny-strindlv/">Jenny&nbsp;Strindlöv</a> | 10 mars 2020<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%2Fhotet-mot-alfahannekollektivet%2F&amp;t=D%C3%A4rf%C3%B6r+nobbar+kvinnorna+extremh%C3%B6gern"    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+nobbar+kvinnorna+extremh%C3%B6gern+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhotet-mot-alfahannekollektivet%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%2Fhotet-mot-alfahannekollektivet%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 nobbar kvinnorna extremhögern&body=https://kvartal.se/artiklar/hotet-mot-alfahannekollektivet/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/14098/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/14098/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%2Fhotet-mot-alfahannekollektivet%2F&amp;t=D%C3%A4rf%C3%B6r+nobbar+kvinnorna+extremh%C3%B6gern"    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+nobbar+kvinnorna+extremh%C3%B6gern+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fhotet-mot-alfahannekollektivet%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%2Fhotet-mot-alfahannekollektivet%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 nobbar kvinnorna extremhögern&body=https://kvartal.se/artiklar/hotet-mot-alfahannekollektivet/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/14098/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/14098/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 href           = "#i-korthet"              class          = "in-short-toggle"         data-articleid = "14098">   <i class="far fa-sticky-note"></i>         <span>I korthet</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 13 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/14098"    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-14098">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "14098"></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"><p>Extremhögern saknar kvinnor.</p>
<p>De menar att kvinnan är vek, svag, passiv och rent instinktivt följer alfahannen.</p>
<p>En stor farhåga för rasnationalisterna är att vita människor ska utrotas. Därför är kvinnan viktig som barnaföderska.</p>
<p>Alternativhögern försöker tukta kvinnor bl.a. genom en nätbaserad sedlighetspolis shariastyle. Men resultatet är klent.</p>
<p>Kvinnan som länge satts på piedestal har alltmer kommit att anta rollen av en femtekolonnare.</p>
<p>&nbsp;</p>
    </div>  </div></div><div class="article-beginning ">När jag 2017 och 2018 infiltrerade svensk extremhöger<sup>1</sup>, eller mer specifikt de kretsar som själva gärna går under namnet ”alternativhögern”, så var det förhållandevis enkelt. </div>
<div class="rest-of-article ">Det pratades förvisso jämt och ständigt om vikten av att vara vaksam mot infiltratörer, och det påstods inte sällan att det gjordes rigorösa säkerhetskontroller innan en ny person släpptes in i den nationella värmen. Detta till trots tog det mig inte mycket mer än några hej och ett leende eller två innan jag välkomnades in i hjärtat av rörelsen. Min egen analys av varför jag fick tillträde så snabbt är väldigt enkel. De saknar kvinnor. Jag är kvinna.</p>
<h2>En rörelse för hela familjen</h2>
<p>Extremhögern vill gärna marknadsföra sig som en ”rörelse för hela familjen”, en beskrivning som bland annat på grund av rörelsens gigantiska överrepresentation av män inte vunnit något direkt förtroende hos den breda allmänheten. Men viljan och längtan är det inget fel på. Under en middag i högkvarteret<sup>2</sup> dryftade en av alternativhögerns många doldisar för mig den ambition som trots allt finns: ”Du vill ju ha mödrar och fäder och familjer som ansluter sig till den här typen av sällskap. Som i kyrkan.” Gång på gång fick jag vetgiriga frågor om vad jag i egenskap av kvinna hade för analys av vad som gett upphov till den förtvivlat stora bristen på just kvinnor. Vad var det som fick mig – som kvinna – att lockas in i rörelsen?</p>
<blockquote><p>De uppfattar kvinnor och män som brutalt väsensskilda.</p></blockquote>
<p>Det påstås ibland med en viss slentrianmässighet om männen inom extremhögern att de hatar kvinnor. Det är en missuppfattning. Min erfarenhet är att de älskar kvinnor ungefär lika mycket som alla andra, de uppfattar bara kvinnor och män som brutalt väsensskilda. Även om den rasistiska ideologin har en tendens att överlappa med de män som kommit att kallas ”incels”<sup>3</sup> så är det orättvist att klumpa ihop de båda grupperna per automatik. Incels hyser agg mot kvinnor för att de inte får ligga – det är i grund och botten personligt. För etnonationalisterna<sup>4</sup> handlar det snarare om en oro över kollektivets överlevnad. Grunden till synen på kvinnan som ett hot är med andra ord snarare att betrakta som politisk.</p>
<figure id="attachment_14314" aria-describedby="caption-attachment-14314" style="width: 591px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-14314 size-full" src="https://kvartal.se/wp-content/uploads/2020/03/Jenny-Strindlov.jpg" alt="Jenny Strindlöv" width="591" height="384" data-wp-pid="14314" srcset="https://kvartal.se/wp-content/uploads/2020/03/Jenny-Strindlov.jpg 591w, https://kvartal.se/wp-content/uploads/2020/03/Jenny-Strindlov-300x195.jpg 300w" sizes="(max-width: 591px) 100vw, 591px" /><figcaption id="caption-attachment-14314" class="wp-caption-text">Jenny Strindlöv. Foto: Privat</figcaption></figure>
<h2>Berättelsen om kvinnans <em>vara</em></h2>
<p>Alla som någon gång skålat i ett glas punsch över en pursvensk ärtsoppa på en högerextrem AW har med stor sannolikhet fått ta del av berättelsen om kvinnans vara. Kvinnans sanna essens. Till sin natur är hon oförmögen att staka ut sin egen väg och fungera som ledare i flocken. Hon är vek, svag, passiv och följer rent instinktivt den starkaste av männen: alfahannen. Det ligger i sakens natur att det tillhör mannens roll – och mannens roll allena – att axla det politiska och idémässiga ansvaret.</p>
<p>När jag vid en fest anordnad av Nordisk alternativhöger<sup>5</sup> småpratade med en av de få kvinnor som fanns på plats, berättade hon för mig att hon hoppat av sin kandidatur till kommunfullmäktige för Sverigedemokraterna. Det var, som hon uttryckte det, inte hennes sak som kvinna att syssla med politik. Hon litade inte på sin känslostyrda natur. Hur skulle hon kunna göra det? Hon hade ju röstat rött en gång i tiden, vilket tydde på dåligt omdöme. Män är rationella och kan till skillnad från kvinnor hålla huvudet kallt, vilket gör dem bättre lämpade för politiskt beslutsfattande, resonerade hon. Denna avhoppade SD-kvinnas sågande av sitt eget omdöme står i stark kontrast till Christoffer Dulnys ogenerade bekännelse att han förr i tiden inte bara röstade rött, utan till och med på Vänsterpartiet. Alternativhögerns vita ledarhäst kryssade Jonas Sjöstedt<sup>6</sup>.</p>
<blockquote><p>Han hade funderat och kommit fram till att kvinnor möjligtvis skulle kunna förtjäna sin rösträtt genom att föda tre barn.</p></blockquote>
<p>Ingen jag talade med under mitt år som innästlad i den mer ljusskygga delen av Stockholms rasnationalistiska kretsar tycker att det är en bra idé med kvinnlig rösträtt. En nyckelperson i den svenska alternativhögern utvecklade sin hållning för mig över ett kallt glas mjöd på en svenskägd pub i Gamla stan. Han hade funderat och kommit fram till att kvinnor möjligtvis skulle kunna förtjäna sin rösträtt genom att föda tre barn. Uttalandet satte genast igång reaktioner från hans nationellt sinnade bordskamrater. Hade han verkligen tänkt igenom det där? Det skulle ju få ödesdigra konsekvenser, menade någon, och påpekade att de som föder flest barn i Sverige faktiskt inte är vita kvinnor. Diskussionen låter kanske perifer, som ett knippe åsikter som endast en utomordentligt sensationslysten journalist från gammelmedia skulle bemöda sig om att återberätta. Men resonemanget är centralt, och speglar i själva verket rasnationalisternas största farhåga: Le grand remplacement. The great replacement. Det stora utbytet.</p>
<h2>Det stora folkutbytet</h2>
<p>Teorin om det stora folkutbytet är mycket enkel. Ett folk (det vita folket) håller på att bytas ut mot ett annat folk (det icke-vita folket, muslimerna, flyktingarna). Inte bara inkräktar de på vitt territorium, de invandrade kvinnorna föder dessutom i regel fler barn än etniskt svenska kvinnor. I en allt mer globaliserad värld blir det därmed allt svårare att tillämpa rasrenhet. Teorin om det stora utbytet myntades och populariserades av fransmannen Renaud Camus 2011<sup>7</sup>. Det senaste året har den fått medial uppmärksamhet i och med terror-massakern på Nya Zeeland då en man öppnade eld och dödade 51 människor vid två moskéer, och skjutningen i El Paso, Texas, då 22 människor dödades. I båda fallen refererade männen bakom avtryckaren till idéen om ”the great replacement”. I den högerextrema marschen i Charlottesville 2017 ekade samma idéer: ”You will not replace us”.</p>
<p>De jag träffat nämner inte det stora utbytet vid namn, men de talar alltjämt om invandringen som en invasion av fiendesoldater, som en lömsk plan iscensatt av judar i syfte att i förlängningen utrota vita människor. Inom extremhögern talar man ofta i termer av ett pågående folkmord. Eller som en av rörelsens frontfigur nyligen uttryckte sig angående de demografiska förändringarna: ”Den största ödesfrågan i vår tid”.</p>
<h2>Högerextremt tankegods i alla tider</h2>
<p>Tanken har funnits och spridits som högerextremt tankegods i alla tider, i olika former och i olika delar av världen. Men deras farhåga kan på sätt och vis sägas mer befogad idag, sett till hur världen faktiskt ser ut. Idag har till exempel en femtedel av Sveriges befolkning utländsk bakgrund<sup>8</sup>, och i USA var majoriteten av alla nyfödda barn 2013 för första gången i den amerikanska historien icke-vita<sup>9</sup>. Att demografin förändras i takt med att människor av olika etniciteter och hudfärg integreras krävs det ingen avlagd examen i raketforskning för att kunna konstatera, men i rasnationalisternas värld är det en fråga om att vinna eller försvinna. ”Även om det vore hyggliga, trevliga japaner med 180 i IQ som vi släppte in så skulle det fortfarande vara ett befolkningsutbyte. Vi har faktiskt rätt att existera”, som en före detta medlem i Svenskarnas parti uttryckte det för mig. Referensen är inte tagen ur luften. Inom extremhögern fungerar Japan med sina låga invandringskvoter som ett föregångsland. Japanerna vet att inte beblanda sig, och det väger tyngre än att befolkningen blir mindre och mindre.</p>
<p>Det är i ljuset av termer som dessa man måste förstå extremhögerns allt aggressivare fokus på kvinnan. Hon har, på grund av sin livmoder och sin självständighet, kommit att bli en maktspelare vare sig hon vill det eller ej. Bara för att du inte är intresserad av politik betyder inte det att politiken inte är intresserad av dig, som Perikles konstaterade redan sisådär 400 år före Kristus.</p>
<p>Länge har kvinnan befunnit sig på piedestal, haft rollen av en värdefull porslinsdocka som måste värnas och skyddas från det utomstående hotet. Nu har hon alltmer kommit att anta rollen av en femtekolonnare.</p>
<blockquote><p>Att föda barn är inte bara ett naturligt steg i livet med någon du älskar. Det är din förbannade plikt.</p></blockquote>
<p>Synen på män och kvinnor som diametralt väsensskilda är för en klassiskt skolad högerextremist i princip lika viktig som rasismen och antisemitismen. Kvinnan ska inte syssla med politik. Hennes roll är bunden till hemmet och spisen. Och framförallt är den bunden till livmodern, denna oersättliga källa till vita små krigare. Vid mer än ett tillfälle fick jag frågan av män inom rörelsen om jag har barn. När svaret var nej fick jag med antydande blickar och gliringar veta att jag vid det här laget (det vill säga som 27-åring) redan borde ha stadgat mig och fött fram ett par tre stycken. Endast vetskapen om extremhögerns besatthet av kvinnan som barnaföderska och frambärare av den vita rasen gör den här typen av kallprat begripligt. Att föda barn är inte bara ett naturligt steg i livet med någon du älskar. Det är din förbannade plikt.</p>
<h2>Svenskor är alltför självständiga</h2>
<p>Problemet är att svenska kvinnor har blivit alldeles för självständiga, de har i rasande fart slingrat sig ur sin gudagivna roll som först och främst gravida hemmafruar. De vill jobba och göra karriär. De vill vänta med barn. Dessutom har de numera privilegiet att välja när, och med vem, och ens om. Preventivmedel och en generös abortlagstiftning ger kvinnan möjlighet att ligga – bara för att det är skönt – och samtidigt välja bort det som kunde ha blivit en ny vit människa. I kampen mot en pågående utrotning av vita människor är detta givetvis problematiskt.</p>
<p>I den högerextrema flocken betraktar man idag det svenska samhället som feminiserat, besudlat av kvinnors mjuka värden och känslodrypande förhållningssätt till verkligheten. Hur många gånger har inte domedagshögern i högkvarteret förfasat sig över hur kvinnor röstar? Ständigt denna rödgrönrosa sörja.<sup>10</sup></p>
<p>Feminismen och kvinnans självständighet har kommit att bli ett hot inte bara mot den högerextrema rörelsen utan också mot hela den vita rasens överlevnad. Något måste göras.</p>
<h2>Nidbild av demoraliserad kvinna</h2>
<p>När gängse extremhöger målar upp sin nidbild av dagens svenska demoraliserade kvinna är det en lådvinsdrickande, pillerknaprande, narcissistisk och sexuellt utsvävande person utan barn som tar form. En sådan där som lägger ut lättklädda bilder av sig själv på sociala medier i syfte att göda sitt redan fördärvade ego. Alternativhögerns senaste kampanjförsök att tukta denna avart av kvinna tog sig nyligen uttryck i en nätbaserad sedlighetspolis shariastyle. Under twitterhashtaggen #skampatrullen har Christoffer Dulny och hans mer eller mindre anonyma fotsoldater gjort det till sin uppgift att skamma kvinnor som antyder något om sin fria syn på sex, eller som på en selfie visar mer hud än vad den självutnämnda skampatrullen anser anständigt.</p>
<p>Även män som bekräftar dessa kvinnors beteende genom att visa offentlig uppskattning för deras utseende eller rycker ut till deras försvar har fått smaka på piskan. Kampanjen har inte bara rönt stor uppmärksamhet i den rasideologiska bubblan, utan till och med letat sig in på gammelmedias territorium<sup>11</sup>. Helt i linje med rasnationalisternas strategi, såklart. Den tuktande effekten tycks däremot, inte helt oväntat, ha uteblivit. Rörelsen i vilken männen är gravt besatta av att identifiera sig själva som alfa och döma ut större delen av den svenska manliga befolkningen som cuckade<sup>12</sup> betamän drar fortfarande inte till sig några horder av kvinnor.</p>
<blockquote><p>Att stå upp för männens idéer om kvinnans roll ger dem bekräftelse, uppmuntran och talrum på den radikalnationalistiska scenen.</p></blockquote>
<p>Under mitt år som wallraffare träffade jag nästan bara män. De få kvinnor som trots allt fanns lärde jag mig att i stora drag dela in i två grupper: flickvännerna och entreprenörerna. Flickvännerna tar i regel ingen plats. Deras roll i sammanhanget är ganska precis vad den låter som: att vara någons flickvän (eller ännu hellre fru). De är ofta medgörliga och till synes bekväma i sina roller som bihang. Entreprenörer kallar jag de kvinnor som ser sina möjligheter att klättra, få makt och bekräftelse genom att fylla rollen som extremhögerns kvinnliga alibin. Dessa har gjort det till sin signaturmelodi att hålla männen om ryggen och propagera deras ideal. Att stå upp för männens idéer om kvinnans roll ger dem bekräftelse, uppmuntran och talrum på den radikalnationalistiska scenen. Men det sker inte utan en överdos av kognitiv dissonans.</p>
<h2>&#8221;Heder och skam&#8221;</h2>
<p>Någon form av rekord uppmättes nyligen när en radikalnationalistisk podd driven av två kvinnor bjöd in Christoffer Dulny för att diskutera ”heder och skam”. Alla tre var rörande överens om mäns och kvinnors skilda kapaciteter och natur. En av kvinnorna uttryckte sig så här:</p>
<p><em>”Det är helt normalt som kvinna att vara ganska självcentrerad och emotionell och ha svårt att se det utifrån. För vi är gjorda för att ha barn helt enkelt och då kan man inte hålla på och prata idéer och så, utan man behöver vara närvarande i sig själv och i barnen. När kvinnor ska ta del av sociala medier eller en diskussion om skampatrull eller skamkultur, då blir det svårt. För kvinnor har inte samma mentala förmåga att diskutera idéer så som män har. Det är svårare för kvinnor att sätta sig själva i ett större sammanhang som män gör. Och det blir ett problem för det är svårt att diskutera över könsgränserna när man inte kommunicerar på samma sätt eller tänker på samma sätt.”</em> <sup>13</sup></p>
<p>Detta gav hon uttryck för i sin egen podd, där hon diskuterar idéer. Som kvinna. Med en man.</p>
<p>Politiska ideologier i allmänhet tenderar förvisso att brottas med en eller flera motstridiga principer, men för de kvinnliga entreprenörerna inom extremhögern är matchen särdeles tuff. Paradoxalt nog är att det inte ens dessa kvinnor som männen i extremhögern i första hand vill ha. De man egentligen vill locka till sig är inte skräniga entreprenörer, utan idémässigt undergivna, vackra, och stöttande fruar som låter männen sköta snacket. Entreprenörerna är bara medel som tillfälligt tillåts ta plats i strävan efter det slutgiltiga målet: den vita etnostaten där män är män och kvinnor är kvinnor.</p>
<h2>Kvinnor måste inte anpassa sig</h2>
<p>Det finns all anledning att ta den ideologiska övertygelsen eller tron som människor ger uttryck för på allvar. Människor tror i regel på det de säger att de tror på, och det gäller förstås lika mycket för kvinnor som för män. Men det går heller inte att förneka att det finns personer för vilka bekräftelse väger tyngre än konsekvent sammanhållna principer, människor som är beredda att sälja om inte sin själ så i alla fall sitt egenintresse för en skopa uppmärksamhet av rätt personer ur sin flock.</p>
<blockquote><p>Rasrenhetens storhetstid är förbi, och det lär bli svårt att avtvinga kvinnor deras en gång hårt förvärvade rättigheter.</p></blockquote>
<p>Ändå: entreprenörerna är och förblir en raritet. Dagens svenska kvinnor har vuxit upp med självständighet, frihet och politisk jämlikhet. De flesta finner det otänkbart att gå till valurnorna för att aktivt rösta bort sin egen rösträtt. Rasrenhetens storhetstid är förbi, och det lär bli svårt att avtvinga kvinnor deras en gång hårt förvärvade rättigheter. Men det finurliga med det moderna samhällets tillämpning av politisk jämställdhet och social frihet är att alla kvinnor inte måste anpassa sig efter vare sig offentlighetens eller hemmets trånga box. De som önskar leva ett traditionellt och rasrent hemmaliv är sålunda redan idag fullt berättigade att göra det.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="14098">  <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, Extremhöger använder jag som samlingsnamn för de män och kvinnor som är aktiva i den rasideologiska miljön, som skulle definiera sig själva som etno- eller rasnationalister (Jämför med Sverigedemokraterna vars officiella hållning är kulturnationalism.) och som motsätter sig jämställda politiska ideal.</p>
<p>2, Högkvarteret: I centrala Stockholm finns det en stor våning som inom högerextrema kretsar kallas för ”högkvarteret”. Den bebos av personer inom rörelsen och fungerar som samlingsplats för framförallt kretsen kring Nordisk alternativhöger. Jag var vid flera tillfällen inbjuden att delta i fester och middagar här.</p>
<p>3, <a href="https://kvartal.se/artiklar/celibat-hat-och-attentat/">https://kvartal.se/artiklar/celibat-hat-och-attentat/</a></p>
<p>4, En etnonationalist menar att nationen bör byggas på en gemensam etnicitet.</p>
<p>5, Nordisk alternativhöger är en form av högerextrem plattform grundad av nyfascisten Daniel Friberg och den före detta SD-toppen Christoffer Dulny.</p>
<p>6, Podd: Vita Pillret, <a href="https://www.spreaker.com/user/nordiskalthoger/loegnarnas-tempel-pilotavsnitt">https://www.spreaker.com/user/nordiskalthoger/loegnarnas-tempel-pilotavsnitt</a>.</p>
<p>7, <a href="https://www.nytimes.com/2019/08/06/us/politics/grand-replacementexplainer">https://www.nytimes.com/2019/08/06/us/politics/grand-replacementexplainer</a>.</p>
<p><a href="https://expo.se/myten-om-det-stora-utbytet">https://expo.se/myten-om-det-stora-utbytet</a></p>
<p>8, SCB: <a href="https://www.scb.se/hitta-statistik/sverige-i-siffror/manniskorna-i-sverige/utrikes-fodda/">https://www.scb.se/hitta-statistik/sverige-i-siffror/manniskorna-i-sverige/utrikes-fodda/</a></p>
<p>9, Andrew Marantz (2019): Antisocial: Online Extremists, Techno-Utopians, and the Hijacking of the American Conversation, s.71.</p>
<p>10, <a href="https://www.svt.se/nyheter/inrikes/svt-novus-tjejerna-valjer-v-och-killarna-valjer-sd">https://www.svt.se/nyheter/inrikes/svt-novus-tjejerna-valjer-v-och-killarna-valjer-sd</a></p>
<p>11, https://www.tv4.se/nyhetsmorgon/klipp/la-upp-bild-p%C3%A5-twitter-jagas-nu-avsedlighetspolis-12514874</p>
<p><a href="https://www.aftonbladet.se/nyheter/kolumnister/a/XgO7Jn/jenny-27-blevuthangd-av-hogerextrem-skampatrull">https://www.aftonbladet.se/nyheter/kolumnister/a/XgO7Jn/jenny-27-blevuthangd-av-hogerextrem-skampatrull</a></p>
<p>12, Kommer från engelskans &#8221;cuckold&#8221;, en term som alternativhögern använder sig av för att attackera den politiska motståndarens förmenta brist på maskulinitet.</p>
<p>13, Podd: Hem och Härd, <a href="https://www.spreaker.com/user/10693067/heder-och-skam-med-chris-dulny">https://www.spreaker.com/user/10693067/heder-och-skam-med-chris-dulny</a></p>
</div>
</div>
<div class="author-byline">Jenny Strindlöv är frilansjournalist. Arbetet hon gjorde som wallraffare i extremhögern har publicerats i bland annat Uppdrag granskning (SVT) och Expressen.
</div>
</div>
