Nye S-toppen stöttar
skandalmoskén i Göteborg

<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-180835"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="1317" data-tin="1522" data-pid="180835" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="TnllIFMtdG9wcGVuIHN0w7Z0dGFyPGJyPnNrYW5kYWxtb3Nrw6luIGkgR8O2dGVib3Jn" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xMS01NS1ueWUtcy10b3BwZW4tc3RvdHRhci1za2FuZGFsbW9za2VuLWktZ290ZWJvcmcubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTEtNTUtbnllLXMtdG9wcGVuLXN0b3R0YXItc2thbmRhbG1vc2tlbi1pLWdvdGVib3JnLm1wMw==">  <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: "><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%2Fnye-s-toppen-stottar-skandalmosken-i-goteborg%2F&amp;t=Nye+S-toppen+st%C3%B6ttar%3Cbr%3Eskandalmosk%C3%A9n+i+G%C3%B6teborg"    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=Nye+S-toppen+st%C3%B6ttar%3Cbr%3Eskandalmosk%C3%A9n+i+G%C3%B6teborg+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnye-s-toppen-stottar-skandalmosken-i-goteborg%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%2Fnye-s-toppen-stottar-skandalmosken-i-goteborg%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Nye S-toppen stöttar<br>skandalmoskén i Göteborg&body=https://kvartal.se/artiklar/nye-s-toppen-stottar-skandalmosken-i-goteborg/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/180835/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="author-section ">  <div class="author-section-inner">    <div class="author-image-holder"><div class="author-image" style="background-image: url('https://kvartal.se/wp-content/uploads/2025/01/Jesper_lowres.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2025/01/Jesper_lowres.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/jesper-andersson/">Jesper&nbsp;Andersson</a> | 12 juni 2025<div class="author-desc">Jesper Andersson är reporter på Kvartal.
</div>    </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%2Fnye-s-toppen-stottar-skandalmosken-i-goteborg%2F&amp;t=Nye+S-toppen+st%C3%B6ttar%3Cbr%3Eskandalmosk%C3%A9n+i+G%C3%B6teborg"    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=Nye+S-toppen+st%C3%B6ttar%3Cbr%3Eskandalmosk%C3%A9n+i+G%C3%B6teborg+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnye-s-toppen-stottar-skandalmosken-i-goteborg%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%2Fnye-s-toppen-stottar-skandalmosken-i-goteborg%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Nye S-toppen stöttar<br>skandalmoskén i Göteborg&body=https://kvartal.se/artiklar/nye-s-toppen-stottar-skandalmosken-i-goteborg/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/180835/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/nye-s-toppen-stottar-skandalmosken-i-goteborg/?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 15 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/dc1c03c1-f437-4a39-9e9c-49926aba7f19"    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-180835">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "180835"></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 "><strong>Jonas</strong> <strong>Attenius</strong> (S) är kommunstyrelsens ordförande i Göteborg och valdes nyligen in som ersättare i Socialdemokraternas högsta beslutande organ, det verkställande utskottet. Han väckte uppmärksamhet förra sommaren när han i Slottsskogen utlovade en bojkott av israeliska varor. Talet skedde inför tusentals personer som hade samlats i parken för högtiden id al-adha i ett arrangemang av Göteborgs moské.</p>
</div>
<div class="rest-of-article ">
<p>Enligt dokument som Kvartal har tagit del av fick Attenius inbjudan att tala i samband med att moskén höll på att bli avhyst från sin filial Hammarkullens moské förra året.</p>
<p>Nu kan Kvartal visa att Jonas Attenius och hans styre har hjälpt församlingen i den omtvistade markfrågan. Den styrande koalitionen i Göteborg, som består av Socialdemokraterna, Vänsterpartiet och Miljöpartiet, har haft flera möten om moskén – trots att det är ett ärende som egentligen ska behandlas av tjänstemännen i staden.</p>
<h2>Framstegskolan, Bellevuemoskén och Göteborgs moské</h2>
<p>Göteborgs moské har nämligen i flera år olovligen i andra hand hyrt en gammal kyrkobyggnad i Hammarkullen, ett utsatt område i Göteborg. Det är den islamiska skolkoncernen Föreningen Framstegsskolan som hyrt ut sina lokaler där Römosseförskolan tidigare huserat, trots att de enligt reglerna inte får användas för annat än skolverksamhet.<sup>1</sup> Det är i flera fall samma personer som dyker upp i bägge verksamheterna, däribland <strong>Mohammad</strong> <strong>El-Alti</strong> som både är ledamot i Framstegsskolans styrelse och ordförande i Göteborgs moské. Han har varit skolans representant i en hyrestvist där skolkoncernen inte betalat in markhyror och haft flera skulder till kommunen.</p>
<blockquote><p>Ett nav för våldsbejakande islamism i Sverige.</p></blockquote>
<p>Föreningen Framstegsskolan drev tidigare bland annat även den skandalomsusade Römosseskolan, som 2022 fick sitt tillstånd indraget av Skolinspektionen.<sup>2</sup> Säkerhetspolisen har tidigare varnat för Römosseskolans band till Muslimska brödraskapet.<sup>3</sup> Skolan har kritiserats för att ha bedrivit könsseparerad undervisning och haft obligatorisk bön.<sup>4</sup> Göteborgs moskés imam <strong>Abdul Rashid</strong> <strong>Mohammed</strong> var även lärare i islamologi på Römosseskolan. 2011 framkom uppgifter om att han krävde att flickor rapporterade när de hade mens, vilket förbjöd dem att delta i bön eller vistas i moskén.<sup>5</sup> Skolans dåvarande rektor, moderate riksdagsledamoten <strong>Abdirizak</strong> <strong>Waberi</strong>, dömdes 2022 för att ha förskingrat runt 13 miljoner kronor och slussat pengarna till Somalia och privata inköp.<sup>6</sup></p>
<p>Göteborgs moské säger att de inte identifierar sig med Muslimska brödraskapet. I ett mejl, som återges i sin helhet nedan, skriver moskéns vd <strong>Faraj Semmo</strong> att den typen av anklagelser är svåra att bemöta, eftersom de ofta används som gummibegrepp och bygger på konspirationsteorier snarare än fakta.</p>
<figure id="attachment_180965" aria-describedby="caption-attachment-180965" style="width: 1024px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="size-full wp-image-180965" src="https://kvartal.se/wp-content/uploads/2025/06/Inline1.jpg" alt="" width="1024" height="576" data-wp-pid="180965" srcset="https://kvartal.se/wp-content/uploads/2025/06/Inline1.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/06/Inline1-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/06/Inline1-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/06/Inline1-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/06/Inline1-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-180965" class="wp-caption-text"><em>Göteborgs moskés vd Faraj Semmo med Jonas Attenius i Slottskogen, Göteborg, den 16 juni 2024. Foto: X</em></figcaption></figure>
<p>Utöver förbindelsen till den kritiserade skolkoncernen har Göteborgs moské genom åren varit inblandad i en rad kontroverser. Imamer har bland annat hållit bön för en dödad Hamasledare,<sup>7</sup> gett utryck för vad kritiker menar är kvinnoförtryckande åsikter<sup>8</sup> och därtill har moskén bjudit in en antisemitisk hatpredikant<sup>9</sup> (se faktaruta nedan). Imamerna som har varit inblandade i kontroverserna är fortfarande aktiva i församlingen.<sup>10</sup></p>
<p>Enligt en väl insatt källa fungerar moskén i Hammarkullen som en förlängd arm till Bellevuemoskén i Göteborg. I en rapport från Försvarshögskolan pekas Bellevuemoskén i Göteborg ut som en central plats för salafistisk verksamhet och som ett nav för våldsbejakande islamism i Sverige.<sup>11  </sup>Moskén har i en rad granskningar avslöjats med terrorkopplingar<sup>12</sup> och Säpo har gjort flera tillslag mot församlingen.<sup>13</sup></p>
<p>När Framstegsskolans kontrakt med staden löpte ut i december 2023 år vägrade skolan och moskén att flytta. I stället har Göteborgs moské försökt få till ett arrendeavtal med kommunen för marken där lokalerna står, men Göteborgs stad har velat avhysa hyresgästerna och hade under 2023 och 2024 planer på att riva lokalerna där moskén huserade.</p>
<p>Men trots stadens planer och trots alla kontroverser som skett inom församlingen beslutade tjänstemännen i exploateringsförvaltningen i april i år att ingå ett avtal med Göteborgs moské om marken i Hammarkullen.<sup>14</sup> Det innebär att moskén kan fortsätta med sin verksamhet i Hammarkullen.</p>
<h2>Socialdemokraterna har förtroende för moskén</h2>
<p>Enligt Kvartals genomgång av mejl och sms engagerade sig Jonas Attenius och det rödgröna styret i moskéns problem redan under vintern 2023 när kontraktet med kommunen löpt ut. Vänsterpartiets kommunalråd <strong>Daniel Bernmar </strong>hade vid tidpunkten kontakt med Göteborgs moskés vd Faraj Semmo och skrev i ett mejl att de rödgröna ”inte såg några hinder” för att gå vidare med moskéns planer på att fortsätta sin verksamhet i Hammarkullen. Men Bernmar hänvisade Semmo till Socialdemokraterna, eftersom de ansvarade för frågan och enligt mejlet hade egna önskemål gentemot moskén. Det kan noteras att i samma mejl från december 2023 skriver Bernmar att de är positivt inställda till moskéns önskemål om att få friköpa marken till församlingens stora moské på Myntgatan i Göteborg, trots att fastighetskontoret redan gett församlingen ett tydligt nej på den ansökan.</p>
<figure id="attachment_180968" aria-describedby="caption-attachment-180968" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-180968 size-full" src="https://kvartal.se/wp-content/uploads/2025/06/Inline2.jpg" alt="" width="1024" height="576" data-wp-pid="180968" srcset="https://kvartal.se/wp-content/uploads/2025/06/Inline2.jpg 1024w, https://kvartal.se/wp-content/uploads/2025/06/Inline2-300x169.jpg 300w, https://kvartal.se/wp-content/uploads/2025/06/Inline2-768x432.jpg 768w, https://kvartal.se/wp-content/uploads/2025/06/Inline2-926x521.jpg 926w, https://kvartal.se/wp-content/uploads/2025/06/Inline2-600x338.jpg 600w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-180968" class="wp-caption-text"><em>Hammarkullens moské. Arkivbild. Foto: Wikimedia Commons</em></figcaption></figure>
<p>Efteråt träffades Attenius och Semmo för att diskutera moskéns önskemål. Under vintern och våren 2024 hade de flera möten, och Semmo bad upprepade gånger Socialdemokraterna om hjälp. Något som partiet agerade på.</p>
<p>Enligt sms- och mejl-korrespondens går det bland annat att se att Socialdemokraterna i Göteborg hade ett möte med förvaltningen om marken. Där medverkade exploateringsnämndens ordförande <strong>Robert</strong> <strong>Hammarstrand</strong> (S), Attenius stabschef och förvaltningens direktör <strong>Kristina</strong> <strong>Lindfors</strong>. I ett sms vid samma period berättade Attenius stabschef för Semmo att han har kontaktat Centerpartiet, som är vågmästare i staden, om moskén i Hammarkullen och ”intygat vilket förtroende vi har för er”.</p>
<p><img decoding="async" class="alignnone wp-image-181060 size-full" src="https://kvartal.se/wp-content/uploads/2025/06/0612-Tidslinje-v2.jpg" alt="" width="815" height="2560" data-wp-pid="181034" srcset="https://kvartal.se/wp-content/uploads/2025/06/0612-Tidslinje-v2.jpg 815w, https://kvartal.se/wp-content/uploads/2025/06/0612-Tidslinje-v2-768x2412.jpg 768w, https://kvartal.se/wp-content/uploads/2025/06/0612-Tidslinje-v2-489x1536.jpg 489w, https://kvartal.se/wp-content/uploads/2025/06/0612-Tidslinje-v2-652x2048.jpg 652w, https://kvartal.se/wp-content/uploads/2025/06/0612-Tidslinje-v2-509x1600.jpg 509w" sizes="(max-width: 815px) 100vw, 815px" /></p>
<p>Den 30 maj 2024 fick Attenius ett vädjande mejl från Semmo som ville skriva ett direktavtal med kommunen och lägga ner ärendet som gått till hyresnämnden: ”Föreningen har uttryckt detta [ett] otal gånger till förvaltningen.” Han mötte motstånd från tjänstemännen inom förvaltningen. Attenius svarade först inte på det, och en dag senare vände sig Semmo i stället till stabschefen via sms där han erbjöd S-politikern att tala inför ”10 000 muslimer” i Slottsskogen den 16 juni 2024. Detta bekräftades och Semmo fick senare svar från Attenius att han bett Robert Hammarstrand ”kika på det”.</p>
<h2>Attenius: En viktig del av Göteborgssamhället</h2>
<p>När Kvartal ringer upp Jonas Attenius säger han att det inte finns något samband mellan Semmos vädjan i markfrågan och talet i Slottsskogen.</p>
<p><span style="font-weight: 400;">Han berättar att det inte enbart är hans stab som har varit i kontakt med förvaltningen om en moské i Hammarkullen. Flera politiker och tjänstemän inom det rödgröna styret i Göteborg har också varit i kontakt med moskén och förvaltningen om arrendeavtalet.</span></p>
<p>Attenius menar att han varken har påverkat myndighetsutövningen eller förvaltningsbeslutet och framhåller att hans engagemang är en del av hans roll som kommunstyrelseordförande. Han nekar till att ha hjälpt moskén.</p>
<p>– Det jag har gjort är att guida rätt. Det gör alla politiker. Det är klart att vi efterfrågar information och en dialog. Det har vi med en mängd olika företag och församlingar. Jag har druckit mer kaffe med den judiska församlingen än med moskén, säger Jonas Attenius.</p>
<p><strong>I Daniel Bernmars (V) mejl till Semmo skriver han att de rödgröna ska gå vidare med hans önskemål om en moské i Hammarkullen, men att det är S som äger den frågan. Därefter tar du över kommunikationen med Semmo. Har det funnits en politisk vilja från Socialdemokraterna om en moské i Hammarkullen?</strong></p>
<p>– Det rödgröna styret har ingenting emot fler kyrkor, moskéer eller synagogor i Göteborg. Vi välkomnar att människor kan utöva sin religionsfrihet. Vi ser ingenting kontroversiellt i att en stor stadsdel som Hammarkullen tillförs en moské, så länge det sker enligt konstens alla regler – som i det här fallet.</p>
<p><strong>I mejlet står det också att ni har haft vissa önskemål från moskén. Vilka var det?</strong></p>
<p>– Vi kommenterar aldrig våra interna diskussioner utåt. Vad Daniel Bernmar menar får han svara på. Däremot kan jag säga att mina allmänna önskemål alltid är att alla processer ska följa alla regler, vilket de har gjort.<strong> </strong></p>
<p>Jonas Attenius känner inte till kopplingen mellan Hammarkullens moské och Bellevuemoskén eller de andra kontroverserna kring Göteborgs moské, med undantag för bönen för den dödade Hamasledaren förra året.</p>
<p>– Sådant som du berättar tar jag helt avstånd från och har nolltolerans för. Jag tar avstånd från all form av extremism. Men jag kan också konstatera att det är Göteborgs största moské, det är väldigt många göteborgare som har den som sin moské.</p>
<p><strong>Nu när du får höra om kontroverserna kring Göteborgs moské – ångrar du att du har hjälpt dem?</strong></p>
<p>– Nej, det gör jag inte såtillvida att de fått hjälp från opartiska tjänstemän och då fått ett kontrakt. Men jag har ingen bekräftelse på att det är på det sättet som du säger. Jag kan inte ha koll på enskilda imamer och usla åsikter som finns i många organisationer.</p>
<p><strong>Hur blir det för demokratin och integrationen i samhället när du hjälper sådana här organisationer att utvidga sin verksamhet i Göteborg?</strong></p>
<p>– Jag tycker att de är en viktig del av Göteborgssamhället, men självklart ska det vara rätt och riktigt, säger han.</p>
<p>Attenius menar att han bara ville förmedla kontakt mellan moskén och Centerpartiet. S-mötet med förvaltningen gällde fastighetstvisten – där man bad dem förmedla information till moskén. Han betonar att han själv inte haft kontakt med enskilda tjänstemän.</p>
<p>Exploateringsförvaltningen, som tecknade avtalet med Faraj Semmo och Göteborgs moské, skriver till Kvartal att beslutet ytterst var förvaltningsdirektören Kristina Lindfors, men att det togs i dialog med den politiska nämnden.</p>
<h2>L: ”Smutsigt agerat”</h2>
<p><strong>Axel</strong> <strong>Darvik</strong>, Liberalernas kommunalråd i Göteborg, har tagit del av Kvartals material och ser allvarligt på Jonas Attenius samröre med moskén.</p>
<p>– Det är ganska smutsigt agerat av Attenius. Det visar på hur man byter röststöd mot tjänster. Han stöttar i praktiken en rörelse av islamister. Det är väldigt konservativa krafter bakom moskén som är kopplade till den islamistiska internationella rörelsen Muslimska brödraskapet.</p>
<p>Darvik hänvisar till Säkerhetspolisens rapporter om Römosseskolan, som kan knytas till Muslimska brödraskapet. Darvik hänvisar också till rapporter som pekar på brödraskapets inflytande i Islamiska förbundet i Sverige – en paraplyorganisation – som bland annat <strong>Ahmed</strong> <strong>Ghanem</strong>, imam vid Göteborgs moské, varit ordförande för.<sup>15</sup></p>
<p>Darvik menar att det rödgröna styret borde ha markerat tydligare mot att moskén och skolan har misskött sig.</p>
<p>– I stället väljer man att gå dem till mötes och ge dem favörer. Jag kan inte tolka det på annat sätt än att Socialdemokraterna försöker köpa sig stöd från muslimer. Det är inte bra att man låter sig korrumperas på det här sättet. Det som är riktigt illa är att Socialdemokraterna utger sig för att stå upp för demokrati, jämställdhet, integration och alla liberala värden vi delar i Sverige. De principerna är inte värda något nu.</p>
<p><strong>Jonas Attenius agerande är troligtvis inte lagstridigt. Går det att tolka som ett hederligt politikerarbete?</strong></p>
<p>– Absolut inte. Man måste som politiker vara noggrann med väljarnas förtroende och visa vilka organisationer man hjälper. Och även väga in det som organisationerna har gjort.</p>
<p>Jonas Attenius säger att Axel Darviks anklagelse om röstfiske är billiga poäng från den borgerliga sidan. Hans kontakt med moskén handlar om att Göteborg är en stor stad och att han behandlar alla lika, oavsett religion.</p>
<h2>Löwenmark: Seger för segregationen</h2>
<p>Kvartal har även pratat med journalisten <strong>Sofie</strong> <strong>Löwenmark</strong>, som driver sajten Doku och sedan länge granskar islamism i Göteborgsområdet. Hon har gått igenom Kvartals material och menar att Jonas Attenius kontakter med den kontroversiella moskén bör ses i ljuset av den franska regeringsrapport som publicerades för ett par veckor sedan.</p>
<p>Rapporten beskriver Sverige som en ”hemvist för en aktiv gren av Muslimska brödraskapet”, där förutsättningarna anses särskilt gynnsamma på grund av ”de goda relationerna mellan rörelsen och lokala politiska partier, i synnerhet Socialdemokraterna”.<sup>16</sup></p>
<p>Sofie Löwenmark har talat med myndighetspersoner och boende i Hammarkullen. Hon säger att myndighetspersoner har berättat för henne, i likhet med Kvartals källa, att moskén i Hammarkullen närmast är en satellitverksamhet till den islamistiska Bellevuemoskén.</p>
<p>Därför har de boende och även myndighetspersoner haft en förhoppning om att kommunen skulle avveckla moskén, enligt henne.</p>
<p>– Att moskén får fortsätta sin verksamhet ser de som en stor förlust för integrationen i samhället och en seger för segregerande strömningar, säger hon.</p>
<h2>Semmo: Ingen kontroversiell verksamhet</h2>
<p>Efter flera påstötningar skickar Faraj Semmo, vd för Göteborgs moské en skriftlig kommentar på mejl. Moskén svarade inte på en fråga om varför imamen mindre än sex månader efter att han höll en bön för en Hamasledare är tillbaka. Svaret i sin helhet anges nedan:</p>
<p><em>Tack för ditt mejl.</em></p>
<p><em>Vi hade önskat ett mer medmänskligt och respektfullt utbyte. Som församling är våra många besökare och medlemmar viktigast. Flera av dina frågor bygger tyvärr på konspiratoriska antaganden om dolda nätverk, och på föreställningar om att svenska muslimer inte skulle ha rätt till en böneplats, något som skapar oro och otrygghet i vårt samhälle. Varför skulle muslimer i Hammarkullen inte ha samma rättigheter som andra trosutövare? Att gång på gång misstänkliggöra muslimska församlingar och deras samhällsengagemang bidrar till ökad islamofobi.</em></p>
<p><em>Vi vill också påpeka några sakfel i frågorna: Hammarkullens moské och Bellevuemoskén är två självständiga församlingar. Påståendet att Göteborgs moské är &#8221;kontroversiell&#8221; saknar grund, vi har dagligen hundratals besökare och årligen tusentals deltagare i våra aktiviteter, utan att det förekommit några större incidenter. Du och din familj är varmt välkomna att besöka oss vid nästa öppna aktivitet. Dialog och samverkan med politiker och andra samhällsaktörer är en självklar del av ett demokratiskt samhälle. Att ifrågasätta detta när det gäller muslimer är olyckligt och riskerar att urholka grundläggande fri- och rättigheter.</em></p>
<p><em>Vad gäller anklagelser om ”Muslimska brödraskapet” är det kort och koncist inget vi identifierar oss som. Den typen av anklagelser är svåra att bemöta, eftersom de ofta används som gummibegrepp och bygger på konspirationsteorier snarare än fakta. Mekanismen påminner om andra historiska exempel där minoriteter misstänkliggjorts kollektivt.</em></p>
<p><em>Göteborgs moské är en öppen och fristående församling som bedriver ett omfattande arbete inom utbildning, socialt stöd, ungdomsverksamhet och interreligiös dialog. Vår verksamhet genomsyras av transparens, ansvar och respekt för samhällets demokratiska principer. Vi hoppas på framtida samtal där saklighet och respekt får stå i centrum. Vi har därför inget ytterligare att tillägga utifrån dessa typer av frågor.</em></p>
<div class = "kv-cruta closed grey cr-round "      id    = "cruta-BGjEgIZYfp"></p>
<h2>Kontroverserna kring Göteborgs moské</h2>
<p><strong>2011: Finansiering från Saudiarabien</strong></p>
<p>Moskéns byggnation, som finansierades helt av Saudiarabien med 67 miljoner kronor, väckte kritik på grund av landets strikta tolkning av islam, wahhabism och salafism. Moskén själv sade att Saudiarabien inte ställde några motkrav.<sup>17</sup></p>
<p><strong>2012: Imams uttalanden om att inte neka sin man sex och motverkan av polisanmälan vid misshandel</strong></p>
<p><strong>SVT</strong>:s <em>Uppdrag Granskning</em> avslöjade att moskéns imam Abdul Rashid Mohammed i en dold inspelning uttalade att polygami är tillåtet under vissa förutsättningar och att en hustru inte kan neka sin man sex om hon inte är sjuk. Han rekommenderade också den kvinnliga besökaren under täckmantel att inte polisanmäla mannen som slog henne.<sup>8</sup> Imamen <strong>Ahmed</strong> <strong>Al-Mofty</strong>, dåvarande ordförande, kallade granskningen för en komplott och sade att SVT var islamofober.<sup>18</sup></p>
<p><strong>2013: Stöd för religiös strid i Syrien</strong></p>
<p>Göteborgs-Posten rapporterade att personer inom moskén argumenterade för att det var rätt att åka till Syrien för att strida mot <strong>Assad</strong>-regimen av religiösa skäl.<sup>19</sup> Moskén förnekade senare detta.</p>
<p><strong>2017: Inbjudan av hatpredikant</strong></p>
<p>Göteborgs moské bjöd in den antisemitiske predikanten <strong>Dhulkarnein</strong> <strong>Ramadani</strong> till en konferens sponsrad av <strong>Ibn</strong> <strong>Rushd</strong> och <strong>Islamic</strong> <strong>Relief</strong>. Ramadani hade året innan uttryckt grovt antisemitiska åsikter, bland annat har han kallat judar för ”smutsiga mikrober” och ”apor och grisar” samt anklagat dem för att döda muslimska barn som ”sakrala offer på altaret till Gud”.<sup>9</sup></p>
<p><strong>2019: Slöjtvång för skolbesök</strong></p>
<p>Moskén meddelade att slöja var ”ett måste” för flickor vid ett planerat skolbesök. Moskén lovade att se över informationen på sin hemsida efter kritiken.<sup>20</sup></p>
<p><strong>2020: Länk till <em>New Muslim Guide</em> och problematisk kvinnosyn</strong></p>
<p>Göteborgs moské kritiserades för att ha en länk på sin hemsida till <em>New Muslim Guide</em>, som innehöll texter om att en hustru inte kan neka sin man sex utan giltiga skäl, till exempel sjukdom eller menstruation.<sup>21</sup> Trots att moskén tog avstånd från innehållet efter TV4:s avslöjande fortsatte de att länka till sajten.<sup>22</sup></p>
<p><strong>2024: Bön för Hamasledaren Ismail Haniyeh</strong></p>
<p>Under en fredagsbön den 2 augusti 2024 hölls en bön för den dödade Hamasledaren <strong>Ismail Haniyeh</strong>, vilket avslöjades av Doku. Moskéns imam, Ahmed Ghanem, beskrev Haniyeh som en civil ledare.<sup>7</sup> Moskéns ledning stängde sedan av två imamer. Redan i januari i år var Ahmed Ghanem tillbaka och föreläste i moskén, enligt moskéns sociala medier.<sup>23</sup></p>
<p>Ahmed Ghanem har varit ordförande för <strong>Islamiska</strong> <strong>förbundet</strong> <strong>i</strong> <strong>Sverige</strong>, som enligt forskaren Aje Carlbom är associerad till islamistiska Muslimska brödraskapet.<sup>15</sup> Förbundet har nekat till dessa kopplingar, men medgav att det kan finnas medlemmar och andra som i sina hemländer haft ideologiska kopplingar till rörelsen.<sup>24</sup></p>
<p>Moskén har återkommande tagit avstånd från extremistiska åsikter.</div>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="180835">  <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><a href="https://www.sverigesradio.se/artikel/staden-kande-till-mosken-i-flera-ar-utan-att-agera"><em>Staden kände till moskén i flera år – utan att agera</em></a> (Sveriges Radio, 24 november 2024)</li>
<li><a href="https://www.svt.se/nyheter/lokalt/vast/stangning-av-romosseskolan-ligger-fast"><em>Römosseskolans stängning kvarstår</em></a> (SVT Nyheter, 12 december 2022)</li>
<li><a href="https://www.dn.se/sverige/tva-friskolor-stangs-risk-att-barnen-radikaliseras/"><em>Två friskolor stängs: ”Risk att barnen radikaliseras”</em></a> (Dagens Nyheter, 5 maj 2022)</li>
<li><a href="https://www.svt.se/nyheter/lokalt/vast/i-over-20-ar-har-elever-delats-upp-efter-kon-pa-lektionerna"><em>Muslimsk skola har haft könsseparerad undervisning i 22 år</em></a> (SVT Nyheter, 8 juli 2020)</li>
<li><a href="https://www.expressen.se/gt/flickor-med-mens-forbjudna-i-mosken/"><em>Flickor med mens förbjudna i moskén</em></a> (Expressen, 9 augusti 2011)</li>
<li><a href="https://www.svt.se/nyheter/lokalt/vast/skolpeng-gick-till-somalia-nu-kommer-domen"><em>Skolpeng gick till Somalia – tidigare rektorn döms</em></a> (SVT Nyheter, 29 april 2022)</li>
<li><a href="https://doku.nu/2024/08/05/bon-for-hamasledaren-i-goteborgs-moske/"><em>Bön för Hamasledaren i Göteborgs moské</em></a> (Sofie Löwenmark och Lars Jonson, Doku, 5 augusti 2024)</li>
<li><a href="https://www.svt.se/nyheter/granskning/ug/imamen-hon-behover-inte-ringa-polisen"><em>Imamen: ”Hon behöver inte ringa polisen”</em></a> (SVT Nyheter, 21 maj 2012)</li>
<li><a href="https://www.expressen.se/debatt/ska-miljoner-fortsatta-ga-till-fusk-judehat-och-islamism/"><em>Ska miljoner fortsätta gå till fusk, judehat och islamism?</em></a> (Magnus Ranstorp, Expressen, 8 september 2020)</li>
<li>https://goteborgsmoske.se/mosken/</li>
<li><a href="https://www.diva-portal.org/smash/get/diva2:1231645/FULLTEXT02.pdf"><em>Mellan salafism och salafistisk jihadism</em></a> (Magnus Ranstorp et al., Försvarshögskolan, 2018)</li>
<li><a href="https://www.expressen.se/gt/terror-rorelsen-varvar-unga-man-i-sverige/"><em>Terror-rörelsen värvar unga män i Sverige</em></a> (Expressen, 5 maj 2010)</li>
<li><a href="https://www.sverigesradio.se/artikel/4701881"><em>Genomsökte byggnad tillhörande moské</em></a> (Sveriges Radio, 18 september 2011)</li>
<li>https://www.instagram.com/goteborgsmoske/p/DH9BYYrtQpr/</li>
<li><a href="https://rib.msb.se/filer/pdf/28248.pdf"><em>Muslimska Brödraskapet i Sverige</em></a> (Red. Magnus Ranstorp, MSB, 2016)</li>
<li><a href="https://www.expressen.se/nyheter/sverige/sverige-pekas-ut-i-fransk-islamistrapport/"><em>Sverige pekas ut i fransk islamistrapport</em></a> (Expressen, 23 maj 2025)</li>
<li><a href="https://www.svt.se/nyheter/granskning/ug/diktaturstaten-saudiarabien-betalar-goteborgs-nya-moske"><em>Diktaturstaten Saudiarabien betalar Göteborgs nya moské</em></a> (SVT Nyheter, 31 oktober 2012)</li>
<li><a href="https://www.gp.se/nyheter/goteborg/imamens-uttalanden-om-kvinnor-uppror.79ae6d28-7bbf-47a2-a7ad-a00808a4f929"><em>Imamens uttalanden om kvinnor upprör</em></a> (Göteborgs-Posten, 30 januari 2013)</li>
<li><a href="https://www.gp.se/nyheter/goteborg/goteborgsmoskeer-uppges-mana-till-strid-i-syrien.57c387e2-3eb6-49a8-ac71-75fbf032ccdb"><em>Göteborgsmoskéer uppges mana till strid i Syrien</em></a> (Göteborgs-Posten, 22 juli 2023)</li>
<li><a href="https://www.svt.se/nyheter/lokalt/vast/otydlighet-kring-sjalkrav-i-goteborgs-moske"><em>Otydlighet om sjaltvång vid besök hos Göteborgs moské</em></a> (SVT Nyheter, 5 april 2019)</li>
<li><a href="https://www.tv4play.se/korthet/6e3267190c36bbd5709b/rad-fran-goteborgs-storsta-moske-kvinnan-far-inte-neka-mannen-sex?panelId="><em>Råd från Göteborgs största moské: Kvinnan får inte neka mannen sex</em> </a>(TV4 Nyheterna, 22 januari 2020)</li>
<li><a href="https://www.gp.se/debatt/goteborgs-moske-legitimerar-asikten-att-en-hustru-inte-kan-neka-sin-man-sex.2d9fb371-4a86-4c54-9527-b0b21e765e8b"><em>Göteborgs moské legitimerar åsikten att en hustru inte kan neka sin man sex</em></a> (Magnus Ranstorp, Göteborgs-Posten, 24 februari 2020)</li>
<li>https://www.youtube.com/@goteborgsmoske/videos</li>
<li><a href="https://www.islamiskaforbundet.se/msb2018/"><em>Kommentarer till Aje Carlboms studie, beställd av myndigheten för samhällsskydd och beredskap</em></a> (Islamiska Förbundet, 16 mars 2018)</li>
</ol>
</div>
</div>
<div class="author-byline">Jesper Andersson är reporter på Kvartal.
</div>
</div>
