När Tyskland blev som vi andra

<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-167261"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="167261" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="TsOkciBUeXNrbGFuZCBibGV2IHNvbSB2aSBhbmRyYQ==" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci81LTU4LW5hci10eXNrbGFuZC1ibGV2LXNvbS12aS1hbmRyYTIubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvNS01OC1uYXItdHlza2xhbmQtYmxldi1zb20tdmktYW5kcmEyLm1wMw==">  <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/joakim-hugert-lundberg/">Joakim&nbsp;Hugert Lundberg</a> | 20 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%2Fnar-tyskland-blev-som-vi-andra%2F&amp;t=N%C3%A4r+Tyskland+blev+som+vi+andra"    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=N%C3%A4r+Tyskland+blev+som+vi+andra+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-tyskland-blev-som-vi-andra%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%2Fnar-tyskland-blev-som-vi-andra%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=När Tyskland blev som vi andra&body=https://kvartal.se/artiklar/nar-tyskland-blev-som-vi-andra/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/167261/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%2Fnar-tyskland-blev-som-vi-andra%2F&amp;t=N%C3%A4r+Tyskland+blev+som+vi+andra"    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=N%C3%A4r+Tyskland+blev+som+vi+andra+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fnar-tyskland-blev-som-vi-andra%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%2Fnar-tyskland-blev-som-vi-andra%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=När Tyskland blev som vi andra&body=https://kvartal.se/artiklar/nar-tyskland-blev-som-vi-andra/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/167261/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/nar-tyskland-blev-som-vi-andra/?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/5e6d1a56-d9dd-4e8e-b206-0df8748c54fc"    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-167261">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "167261"></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>Friedrich Merz</strong> såg tom ut på onsdagseftermiddagen den 29 januari. Trots att den kristdemokratiska kanslerkandidatens förslag om skärpt asylpolitik precis vunnit en majoritet i förbundsdagen. Det var en historisk dag i tysk politisk historia. För första gången fick CDU igenom ett förslag med hjälp av Alternativ för Tyskland (AfD).</p>
</div>
<div class="rest-of-article ">
<p>Sedan dess anklagas Merz för att ha eroderat ”brandväggen”, som innebär att de etablerade partierna till varje pris ska utestänga AfD från politiskt inflytande. Ett slags Decemberöverenskommelse, om man så vill.</p>
<p>Den dramatiska veckan slutade i antiklimax för Merz när hans uppföljande asylförslag två dagar senare röstades ned. 12 röster skilde. Det innebär att hans egna ledamöter vacklade. Möjligtvis påverkade av att tidigare förbundskanslern <strong>Angela Merkel</strong>, som för över tjugo år sedan utmanövrerade Merz i kampen om partiledarrollen, för ovanlighetens skull gick ut och kritiserade sin efterträdare.</p>
<p>På Kristdemokraternas partikongress veckan därpå höll Merz fast vid sin linje att begränsa migrationen, trots den omfattande kritiken, samt att återställa den svaga tyska ekonomin. Han tog ännu en gång avstånd från AfD med orden:</p>
<p>– Det här partiet står emot allt som vårt parti och vårt land har byggt upp.</p>
<h2>Tyskarna vill ha hårdare migrationspolitik, men inte med AfD</h2>
<p>Men ilskan, och besvikelsen, mot CDU och Merz har varit enorm de senaste veckorna. Förbundskansler <strong>Olaf Scholz</strong>, som brottas med låga opinionssiffror, anser inte att Merz går att lita på längre. Hans socialdemokratiske partikollega, <strong>Rolf Mützenich</strong>, anklagar CDU-ledaren för att ha &#8221;öppnat dörren till helvetet”. Demonstrationer har rasat över hela landet. I Berlin gick 160 000 människor ut på gatorna helgen efter den historiska omröstningen. I München uppgick antalet demonstranter till åtminstone 250 000. <strong>Albrecht Weinberg</strong>, överlevare från Auschwitz, återlämnade sin <em>Bundesverdienstkreuz</em>, Tysklands enda statsorden.</p>
<p>Samtidigt visar opinionsundersökningar att en majoritet av befolkningen (69 procent) stödjer CDU:s förslag om skärpt migrationspolitik.<sup>1</sup> Men många (44 procent) ifrågasätter att använda sig av AfD:s röster för att bedriva politiken. Man hade hellre velat se enighet i den politiska mitten, och att socialdemokraterna hade godkänt Merz förslag.</p>
<p>Hela 76 procent av tyskarna anser att den nuvarande migrationspolitiken är felaktig, enligt opinionsinstitutet INSA. 51 procent tycker att Tyskland bör stänga sina gränser, även om det bryter mot EU-lagstiftning.</p>
<p>Merz första förslag innehöll fem punkter. Inreseförbud för alla utan giltiga dokument, vilket betyder att Tyskland upphör att ta emot asylsökande vid gränsen. Polisen skulle få rätt att gripa personer som fått beslut om deportering. Obligatoriskt förvar för alla med utvisningsbeslut. Fler utvisningar på förbundsnivå. Helst dagligen, enligt Merz. Och slutligen, tvångsutvisningar för dem som begått brott.</p>
<blockquote><p>Förra veckans attentat i München innebär att Tyskland på knappt nio månader har drabbats av fem dåd utförda av män med asylbakgrund.</p></blockquote>
<p>Det som fick Merz att ta beslutet att ignorera om AfD stödde hans förslag – och satte migrationen i centrum av valrörelsen – inträffade i bayerska Aschaffenburg i slutet av januari. En afghansk man från ett asylboende i närheten attackerade en förskoleklass i en lekpark med en kniv. En tvåårig pojke och en 41-årig man, som försökte stoppa attacken, dödades. Enligt polisen var mannen psykiskt sjuk.</p>
<p>Förra veckans attentat i München innebär att Tyskland på knappt nio månader har drabbats av fem dåd utförda av män med asylbakgrund. I München dog en mor och hennes tvååriga dotter, och minst 36 människor skadades efter att en afghansk man kört in en bil i en folksamling. Polisen utreder islamistiskt motiv.</p>
<h2>Kommer AfD bli salongsfähiga?</h2>
<p>Som oppositionsledare var Merz tvungen att agera, säger <strong>Klaus Schroeder</strong>, professor i statsvetenskap vid Freieuniversitetet i Berlin.</p>
<p>– Befolkningen vill ha en hårdare migrationslinje, och de flesta partier inser det. Men han hade inte räknat med att ledamöter från den gamla Merkelfalangen, som fortfarande finns i partiet, skulle rösta mot honom. Han borde ha säkrat upp att det fanns stöd i sitt eget parti, eftersom Merkel fortfarande har inflytande över CDU.</p>
<p>Schroeder tror däremot inte att kristdemokraterna kommer att ingå i ett formellt regeringssamarbete med AfD under Merz ledarskap.</p>
<p>Men frågan är hur länge man kan hålla ett parti som AfD borta från politiskt inflytande – fastän de fortsätter att växa.</p>
<p>– Så länge de fortsätter att vara så här radikala och ociviliserade. De är långtifrån regeringsdugliga. Jag anser inte att det är möjligt att ett sådant parti får reell makt i Tyskland, säger Klaus Schroeder.</p>
<h2>Återvändande, Moskva och vindkraft</h2>
<p>AfD betraktas som delvis högerextremt av det tyska författningsskyddet och övervakas i tre förbundsländer. De vill lämna EU, euron och Nato – och närma sig Ryssland genom att upphäva sanktionerna, men också ta Nord Stream-ledningen i bruk för att kunna importera billig rysk gas igen.</p>
<p>Därtill vill partiet kraftigt minska stödet för förnybar energi. Partiledaren tillika kanslerkandidaten <strong>Alice Weidel</strong> talar om ”skammens vindkraftverk”, och att alla dessa kommer att rivas när AfD sitter vid rodret.</p>
<p>Partiet stödjer fortsatt kolkraft och tycker att det var ett misstag att lägga ned kärnkraften. AfD vill lämna Parisavtalet och motsätter sig även ett förbud mot förbränningsmotorer i bilar och ingrepp i olje- och gasuppvärmningssystem.</p>
<p>Under valrörelsen har Weidel försökt återta begreppet ”remigration” – en fackterm som syftar på att migranter återvänder till sitt hemland, men som på senare år har blivit ett flitigt använt slagord i högerextrema kretsar med hänvisning till massutvisning av personer med invandrarbakgrund i Tyskland.</p>
<p>Weidel betonar att termen för henne gäller människor som inte har rätt att vistas i Tyskland , som ”kriminella, människor som inte kan bete sig, och som inte kan bidra positivt till vårt samhälle, och inte har någon plats i detta land”.<sup>2</sup></p>
<h2>Migrationen är inte den enda förklaringen</h2>
<p>AfD sticker ut på flera sätt bland Europas ytterhögerpartier. Det säger <strong>Constantin Wurthmann</strong>, statsvetare vid universitetet i Mannheim, som forskar om väljarbeteenden och politiska attityder.</p>
<p>– De har företrädare som leker med nazistspråk och relativiserar Förintelsen. Även inom den radikala högern i Europa betraktas de som för extrema. Inte ens <strong>Le Pen</strong> vill samarbeta med dem i Europaparlamentet. Det går inte att jämföra AfD med övriga partier på den här sidan av politiken.</p>
<p>Att AfD nu står i centrum av den politiska debatten är något partiet gläds åt, enligt Wurthmann.</p>
<p>– Det är ett återkommande misstag som tyska medier begår, att ständigt prata om AfD. Vi pratar sällan om vilka som röstar på AfD och varför.</p>
<p>Förutom migrationen finns det flera faktorer som förklarar varför väljare röstar på AfD, betonar Wurthmann:</p>
<p>– Framgångarna i forna öst bygger på att AfD presenterar sig som företrädare för en östtysk identitet. Deras röst mot eliten i väst. Även fast de flesta ledande företrädare i AfD faktiskt kommer från väst själva. Kriget i Ukraina är förstås också viktigt. Dessa väljare motsätter sig tyska vapenleveranser och fortsatt stöd till Ukraina.</p>
<h2>Regeringsinflytande om 5 år?</h2>
<p>Denna valrörelse är ovanligt hektisk. Det menar <strong>Ferdinand Otto, </strong>som är politikredaktör på den inflytelserika veckotidningen <em>Die Zeit</em> och som har bevakat många tyska valkampanjer.</p>
<p>– Det som utlöste nyvalet, regeringskollapsen i november, var disruptivt. Sedan dess har tonläget stundtals varit oförsonligt.</p>
<p>Han drar en parallell till ett grannland på frågan om när AfD kan tänkas sitta i en regering.</p>
<p>– I Österrike tog det över 20 år innan FPÖ kom i en minoritetsregering. Det finns stora skillnader mellan våra länder och politiska kulturer, men eftersom AfD grundades för knappt 10 år sedan, skulle det innebära att vi kanske har 5–10 år innan de eventuellt skulle kunna få regeringsinflytande i Tyskland, säger Ferdinand Otto.</p>
<p>AfD skulle kunna vinna fler röster om de gick åt mitten i vissa frågor, bedömer han.</p>
<p>– Till exempel motståndet mot EU och euron. Men de gör inte det. De måste bestämma sig själva för att reformeras, men jag tror inte ens att de på allvar vill försöka bli mer av ett mittenparti, och därmed blir de bara mer radikaliserade.</p>
<h2>Kenyakoalition det troligaste regeringsalternativet</h2>
<p>Samtidigt tycks de etablerade partierna stå handfallna och deras uteslutning av AfD verkar bara få partiet att fortsätta växa. De är sedan länge näst största parti och pendlar runt 20 procent i opinionen.</p>
<p>Även efter sin öppning mot AfD leder CDU mätningarna på drygt 30 procent. Merz har upprepade gånger bedyrat att ett samarbete med AfD är uteslutet.</p>
<blockquote><p>Infrastrukturen behöver rustas upp; digitaliseringen är närmast obefintlig.</p></blockquote>
<p>Frågan är vilka partier som kan tänkas ingå i en koalitionsregering.</p>
<p>– Kristdemokrater, socialdemokrater och gröna är alla beredda och vana vid att kompromissa. Det stora problemet för CDU är deras systerparti i Bayern, CSU, som motsätter sig all form av samarbete med De gröna. Det sätter stor press på Merz och det kommer bli svårt för honom i kommande förhandlingar med De gröna och SPD som troligen väntar, säger statsvetaren Constantin Wurthmann.</p>
<p><strong>Ulf Poschardt</strong>, fram till nyligen chefredaktör på <em>Die Welt</em>, förutspår att en så kallad <a href="https://en.wikipedia.org/wiki/Black-red-green_coalition">Kenyakoalition </a>med kristdemokrater, socialdemokrater och gröna kommer leda till ett AfD med över 30 procent väljarstöd vid årsslutet.<sup>3</sup></p>
<h2>Ett krisartat land som bara blir fattigare</h2>
<p>Behovet av strukturella reformer i Tyskland är skriande. Ekonomin sviktar i den stolta industrinationen. Infrastrukturen behöver rustas upp; digitaliseringen är närmast obefintlig.</p>
<p>Modellen som har lett till tysk ekonomis uppsving de senaste decennierna har på kort tid fullständigt rasat samman: billig rysk gas till en energiberoende inhemsk industri, som sedermera kan exportera förmånligt till Kina, samtidigt som USA skänker militärt skydd.</p>
<p>Ett Tyskland som bara blir fattigare och fattigare kan inte ses som positivt ur någon som helst europeisk synvinkel.</p>
<p>Eller som <em>Wall Street Journals</em> Europakorrespondent<strong> Bojan Pancevski</strong> formulerade det på X nyligen: ”Utan Tyskland är Europa ett uppsvällt ålderdomshem med ett stort bolån.”<sup>4</sup><a href="#_ftnref1" name="_ftn1"></a></p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="167261">  <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>Bild/INSA (2025-01-31)</li>
<li>ZDF (2025-01-12)</li>
<li>Ulf Poschardt, inlägg på X (2025-02-12)</li>
<li>Bojan Pancevski, inlägg på X (2025-01-15)</li>
</ol>
</div>
</div>
<div class="author-byline">Joakim Hugert Lundberg är frilansjournalist baserad i Berlin med bakgrund på TT Nyhetsbyrån, Sveriges Radio Ekot och tyska tidningen Der Tagesspiegel.
</div>
</div>
