Lever vi i en ny grön bubbla?

<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 class="kv-pod-holder kv-player-light" data-sid="" data-eid="" data-pid="92685" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva3ZhcnRhbC9pbmxhc3RfbGV2ZXJfdmlfaV9lbl9ueV9ncm9uX2J1YmJsYS5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvbGV2ZXItdmktaS1lbi1ueS1ncm9uLWJ1YmJsYV8ubXAz">  <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/christian-sandstrm/">Christian&nbsp;Sandström</a> | 12 april 2023<div style="float: right;" class="social-top-wrapper closed no-comments"><div class="share-icons"><span class="share-outer"><a href="https://www.facebook.com/sharer.php?u=https%3A%2F%2Fkvartal.se%2Fartiklar%2Flever-vi-i-en-ny-gron-bubbla%2F&amp;t=Lever+vi+i+en+ny+gr%C3%B6n+bubbla%3F"    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=Lever+vi+i+en+ny+gr%C3%B6n+bubbla%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Flever-vi-i-en-ny-gron-bubbla%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%2Flever-vi-i-en-ny-gron-bubbla%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Lever vi i en ny grön bubbla?&body=https://kvartal.se/artiklar/lever-vi-i-en-ny-gron-bubbla/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/92685/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/92685/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%2Flever-vi-i-en-ny-gron-bubbla%2F&amp;t=Lever+vi+i+en+ny+gr%C3%B6n+bubbla%3F"    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=Lever+vi+i+en+ny+gr%C3%B6n+bubbla%3F+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Flever-vi-i-en-ny-gron-bubbla%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%2Flever-vi-i-en-ny-gron-bubbla%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Lever vi i en ny grön bubbla?&body=https://kvartal.se/artiklar/lever-vi-i-en-ny-gron-bubbla/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/92685/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/92685/pdf"    target = "_blank"    class  = "pr-link"    title  = "Ladda ner artikeln som PDF"><i class="fas fa-file-pdf ui transparent"></i></a></span><a href="#share" class="share-expand "    title="Visa fler delningsalternativ"><i class="fas fa-share-square ui transparent"></i></a></div></div><div class="article-actions"><a href="/profile" class="kv-aa-profile"><svg aria-hidden="true">  <use href="#tf-ti-user"></use></svg><span>Profil</span></a><a class="listen" href="https://kvartal.se/artiklar/lever-vi-i-en-ny-gron-bubbla/?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 12 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/92685"    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-92685">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "92685"></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  rest-hidden "><strong>Irene Svenonius</strong> (M) skrev i januari på <a href="https://www.di.se/debatt/replik-centerpartiet-lever-i-en-gron-bubbla/">Di Debatt att Centerpartiet lever i en grön bubbla</a>. Frågan är om inte hela landet har levt i en grön bubbla de senaste två decennierna.</p>
</div>
<p><a class="shadow-button noselect article-read-more-btn las-mer-92685"  data-articleid="92685">  <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">Läs mer</span>      <span class="open-text">Visa mindre</span>    </span>  </span></a></p>
<div class="rest-of-article  hidden ">
<p>Det finns i Sverige så många misslyckade satsningar på så kallad grön teknik och grön omställning att vi måste börja tala om ett mönster och granska de politiska systemfel som ger upphov till gröna bubblor. Den som ägnar lite tid åt fenomenet gröna bubblor överväldigas lätt av alla skräckhistorier som går att finna på lokal, regional och nationell nivå.</p>
<p>Den pågående ”gröna boomen” i Norrland behöver därför skärskådas i ljuset av alla dessa sentida misslyckanden.</p>
<h2>Etanolbubblan</h2>
<p><a href="https://www.nationalekonomi.se/sites/default/files/2022/08/50-5-csrb.pdf">2004-2008 blåstes en bubbla av etanolbilar</a>. Generösa avdrag och tvingande lagstiftning drev upp nybilsförsäljningen av etanolbilar till 20 procent av marknaden 2008 innan den i nästa skede punkterades av skurna motorer och arga konsumenter som fick bekosta reparationerna.</p>
<figure id="attachment_92700" aria-describedby="caption-attachment-92700" style="width: 1204px" class="wp-caption alignnone"><img fetchpriority="high" decoding="async" class="wp-image-92700 size-full" src="https://kvartal.se/wp-content/uploads/2023/04/G1-.png" alt="kvartal" width="1204" height="778" data-wp-pid="92700" srcset="https://kvartal.se/wp-content/uploads/2023/04/G1-.png 1204w, https://kvartal.se/wp-content/uploads/2023/04/G1--600x388.png 600w, https://kvartal.se/wp-content/uploads/2023/04/G1--300x194.png 300w, https://kvartal.se/wp-content/uploads/2023/04/G1--768x496.png 768w" sizes="(max-width: 1204px) 100vw, 1204px" /><figcaption id="caption-attachment-92700" class="wp-caption-text">Figuren föreställer antalet nyregistrerade etanolbilar i Sverige över tiden. Källa: Sandström, C., Björnemalm, R. (2022) ”Hur uppstår gröna bubblor? Lärdomar från etanolbubblan som sprack”, <em>Ekonomisk Debatt</em>, 50(5), ss. 65-71.</figcaption></figure>
<h2>Dyr etanolproduktion</h2>
<p><a href="https://www.skattenytta.se/wp-content/uploads/2022/12/Skattenytta-i-miljosatsningar_FINAL.pdf">I Örnsköldsvik skulle ett kommunägt bolag vid namn Sekab göra etanol ur skogen</a>. Under de febrigaste åren 2004-2007 besöktes Sekab av ministrar, ambassadörer, kungligheter och delegationer från hela världen. Efter eskapader utomlands till Tanzania, Mozambique, Polen, Ghana och Ungern slutade det med ett skuldberg på miljarder för kommunens invånare.</p>
<figure id="attachment_92701" aria-describedby="caption-attachment-92701" style="width: 1225px" class="wp-caption alignnone"><img decoding="async" class="wp-image-92701 size-full" src="https://kvartal.se/wp-content/uploads/2023/04/G2.png" alt="" width="1225" height="765" data-wp-pid="92701" srcset="https://kvartal.se/wp-content/uploads/2023/04/G2.png 1225w, https://kvartal.se/wp-content/uploads/2023/04/G2-600x375.png 600w, https://kvartal.se/wp-content/uploads/2023/04/G2-300x187.png 300w, https://kvartal.se/wp-content/uploads/2023/04/G2-768x480.png 768w" sizes="(max-width: 1225px) 100vw, 1225px" /><figcaption id="caption-attachment-92701" class="wp-caption-text">Figuren föreställer antalet sålda etanolbilar i Sverige över tiden. Källa: Sandström, C., Björnemalm, R. (2022) &#8221;Hur uppstår gröna bubblor? Lärdomar från etanolbubblan som sprack&#8221;, <em>Ekonomisk Debatt</em>, 50(5), ss. 65-71.</figcaption></figure>
<p>År 2007 invigde jordbruksminister <strong>Eskil Erlandsson</strong> (c) Lantmännens etanolfabrik i Norrköping. Målet var att 2008 tillverka 210 miljoner ton drivmedelsetanol per år med vete som insatsvara. Utan tullar på etanol från Brasilien fanns det dock ingen konkurrenskraft i produktionen, och efterfrågan på etanol som bränsle var dessutom manipulerad via regleringar.</p>
<p>Två år efter att fabriken sattes i drift 2008 hade den kostat Lantmännen 233 miljoner kronor. VD för Agroetanol, <strong>Kenneth Werling</strong>, var själv kritisk till projektet som han var chef för och sa följande till SVT 2007: ”Om jag hade varit ägare skulle jag aldrig ha gjort den här investeringen.” Werling fick sedan avgå som en följd av detta uttalande.</p>
<p>Agroetanol utvecklas under 2000-talet till en <a href="https://timbro.se/smedjan/etanolbubblan-som-sprack/">utdragen härva</a> av förluster för ägarna och miljöbrott. Bidrag, subventioner och skyddande tullar räckte i slutändan inte särskilt långt.</p>
<figure id="attachment_92710" aria-describedby="caption-attachment-92710" style="width: 1425px" class="wp-caption alignnone"><img decoding="async" class="wp-image-92710 size-full" src="https://kvartal.se/wp-content/uploads/2023/04/NY-graf.png" alt="" width="1425" height="643" data-wp-pid="92710" srcset="https://kvartal.se/wp-content/uploads/2023/04/NY-graf.png 1425w, https://kvartal.se/wp-content/uploads/2023/04/NY-graf-600x271.png 600w, https://kvartal.se/wp-content/uploads/2023/04/NY-graf-300x135.png 300w, https://kvartal.se/wp-content/uploads/2023/04/NY-graf-768x347.png 768w" sizes="(max-width: 1425px) 100vw, 1425px" /><figcaption id="caption-attachment-92710" class="wp-caption-text">Figuren föreställer antalet etanolbilar i trafik jämfört med elbilar och hybrider. Källa: Sandström, C., Björnemalm, R. (2022) &#8221;Hur uppstår gröna bubblor? Lärdomar från etanolbubblan som sprack&#8221;, <em>Ekonomisk Debatt</em>, 50(5), ss. 65-71.</figcaption></figure>
<p>Det finns också många små satsningar på etanol, som aldrig hann bli stora innan bubblan sprack. Här rör det sig snarare om några tiotals miljoner i bidrag som kombinerats med pengarna från kommunala bolags interna kassakistor. Bland dessa märks Höglandsetanol i Nässjö, Karlskoga Biofuel, Laga Bioetanol i Laholm och Nordisk Etanolproduktion, som skulle etablera sig i Karlshamn och Sölvesborg, samt Sala Heby Energi och Härjedalens Miljöbränsle AB, som skulle samarbeta med kinesiska National Bio Energy.</p>
<h2>Dyra biogasbubblor</h2>
<p>I Göteborg skulle Gobigas-satsningen <a href="https://www.skattenytta.se/wp-content/uploads/2022/12/Skattenytta-i-miljosatsningar_FINAL.pdf">utveckla metangas</a> från kvistar och grenar, gasen skulle dessutom på sikt användas som bränsle i regionens fordonsflotta. Tekniken fungerade emellertid inte, nedskrivningarna och kostnader på totalt två miljarder lämpades i slutändan över på kommunens skattebetalare. Politikerna och arkitekterna bakom initiativet skyllde på bristande stöd från politiken; 222 miljoner kronor från Energimyndigheten och en halv miljard från EU var inte tillräckligt.</p>
<p>I Mälardalen skulle kommunala Vafab <a href="https://timbro.se/smedjan/en-platko-som-kunde-mjolkas-pa-eu-bidrag/">utveckla en ”plåtko”</a>, en form av biogasproduktion som industrialiserar den nedbrytningsprocess som pågår i en kos mage. Tekniska problem och glädjekalkyler medförde i nästa skede ett penibelt och utdraget städjobb.</p>
<p>Borås Energi &amp; Miljö initierade en satsning på att röta gammal frukt i Indonesien. Pengar från Sida och andra myndigheter kombinerades med kommuninvånarnas pengar i ytterligare en misslyckad satsning.</p>
<blockquote><p>Den snabba expansionen av vindkraften i den svenska energimixen kan också sägas vara en grön bubbla även på det nationella planet.</p></blockquote>
<p>Även Luleå kommun gjorde en besinningslös satsning på biogas. Socialdemokraten <strong>Niklas Nordström</strong> fick städjobbet på sitt bord när han tillträdde som kommunalråd. I efterhand har han beskrivit att det inte fanns något skriftligt dokumenterat beslutsunderlag alls. Tiotals miljoner hade investerats utan någon ordentlig förstudie.</p>
<p>Söderhamns kommun var i eget tycke ”världsledande” på biogas med den satsning som sjösattes år 2012. Några år senare fick man konstatera att ”det kom ren och fin gas men inte så mycket”, det som kostat nio miljoner att bygga såldes nu för 40 000 kronor till en lantbrukare som förbarmade sig. Biogasanläggningen hamnade år 2020 på Skattebetalarnas <a href="https://skattebetalarna.se/arets-varsta-sloseri-2020-bidragen/">lista över årets värsta slöseri</a>.</p>
<h2>Vindkraftsbubblor</h2>
<p>Inget vet hur många misslyckade satsningar på biogas som gjorts i olika kommunala bolag. Ingen vet heller hur många likartade investeringar i vindkraft som slutat i förluster, skulder och nedskrivningar.</p>
<ul>
<li>2012 köpte region Gävleborg in två vindkraftverk för 85 miljoner kronor. Den förväntade årliga vinsten på tre miljoner kronor blev i stället ytterligare 42 miljoner i kostnader och <a href="https://www.svt.se/nyheter/lokalt/gavleborg/regionen-saljer-sina-vindkraftverk-med-jatteforlust">den totala notan landade på 127 miljoner</a>.</li>
<li>Örebro och Kumla Kommun satte upp ett gemensamt bolag vid namn Kumbro vind som fick i uppdrag att bygga och driva vindkraftparker. Tillstånden hade dock inte vunnit laga kraft och i slutändan fick förlusten lämpas över på skattebetalarna. Örebro och Kumla fick skjuta till 25 miljoner i ägartillskott för år 2022. Året innan låg förlusten på 19 miljoner. <strong>Per Erik Andersson</strong> (s) har en enkel förklaring: ”det har blåst för lite”. Det hindrade inte dåvarande energiminister <strong>Khashayar Farmanbar</strong> (s) från att besöka Kumbro och <a href="https://stadsnat.se/blogg/energiministern-besokte-kumbro/">lovorda hur tysta vindkraftverken var</a>.</li>
<li>Vindkraftsbolaget Triventus blev ”årets gasellföretag år 2010” och fick omkring 100 miljoner från Industrifonden. Fyra år senare befann sig företaget i rekonstruktion.</li>
<li>Karlstad Energi gjorde år 2012 en förlust på 48 miljoner i fiaskoprojektet ”Vindkraft Vänern”. Satsningen invigdes år 2010 och bara 2013 <a href="https://www.svt.se/nyheter/lokalt/varmland/ekonomiska-problem-for-vindpark-vanern">summerades förlusterna</a> till 120 miljoner då vindsnurrorna inte fungerade.</li>
<li><a href="https://www.gd.se/2015-05-26/en-bra-affar-for-gavle-kommun--hur-da">Vindkraftsbolaget ”Samkraft AB” saknade 100 miljoner år 2014</a> och behövde snabbt få in pengar, ett haveri som fick bekostas av kommuner som Gävle, Sandviken, Söderhamn, Eskilstuna, Bollnäs, Ljusdal och Nordanstig.</li>
<li>Vindkraftsbolaget Kalix Vind och dotterbolaget Bottenviken med åtta vindkraftverk i Norrbotten <a href="https://www.svt.se/nyheter/lokalt/norrbotten/vindkraftbolag-ansoker-om-konkurs">ansökte om konkurs 2017</a>.</li>
</ul>
<p>Vissa har dock tjänat på vindkraften. Före detta näringsminister <strong>Maud Olofssons</strong> son är vindkraftsmiljonär. Det har nog inte varit en nackdel att vara släkt med en före detta näringsminister, som dessutom länge gått i bräschen för vindkraften. Många centerpolitiker i kommuner och regioner kombinerar politiska uppdrag med att arbeta åt vindkraftsindustrin, antingen som markägare, konsulter eller genom diverse bolagsengagemang.</p>
<p>Den snabba expansionen av vindkraften i den svenska energimixen kan också sägas vara en grön bubbla även på det nationella planet. Direkta och indirekta stöd till vindkraften har kombinerats med ihålig retorik om hållbarhet. Redan 2009 <a href="https://www.nyteknik.se/energi/kaberger-skaller-ut-frank/107570">förklarade</a> <strong>Harry Frank</strong> och andra ledande forskare att det svenska elsystemet inte klarar mer än 10 TWh från vindkraften per år, vilket gjorde dåvarande GD:n för Energimyndigheten <strong>Thomas Kåberger</strong> rasande. Varningarna ignorerades och idag är vi uppe i 28 TWh från vindkraft, cirka tre gånger mer än vad experter bedömde som hanterbart.</p>
<p>Utöver vindkraften, biogasen och etanolen kan den <a href="https://timbro.se/smedjan/bidragskapitalisterna-som-fick-slut-pa-batteri/">nyligen aviserade</a> konkursen av Britishvolt ses som ytterligare ett exempel på en grön bubbla.</p>
<h2>Ett politiskt systemfel</h2>
<p>När så många företag, politiker och anställda i kommuner och myndigheter satsat så stora resurser och gjort så mycket skada är det inte frågan om inkompetens eller dåligt uppsåt. De främsta forskarna och ingenjörerna har ofta involverats och fått stora mängder resurser till sitt förfogande.</p>
<p>De gröna bubblorna kan därför inte förklaras med inkompetens eller brist på resurser. Det rör sig snarare om ett <a href="https://www.nationalekonomi.se/sites/default/files/2023/02/51-1-csrb.pdf">systemfel</a> som ger upphov till ett mönster, vilket upprepat sig gång på gång. I grova drag är mönstret följande:</p>
<ol>
<li>Offentligt ägda bolag är en perfekt grogrund för gröna bubblor. Bidrag på hundratals miljoner, ofta från Energimyndigheten och EU kan kombineras med bolagets egna pengar, som ytterst också tillhör skattebetalarna.</li>
<li>Ingen risk är för stor när någon annan betalar. Glädjekalkyler får fäste och orealistiska satsningar görs, ingen lyssnar på fåtalet kritiska röster, som enkelt kan avfärdas med smädesord som ”nyliberal”, ”klimatförnekare” eller ”olyckskorp”.</li>
<li>Politiker – oavsett partifärg – solar sig i fägringen av satsningarna. Band kan klippas, retorik om gröna jobb, ”världsledande”, återindustrialisering, framtidens exportindustri med mera går som ett eko genom 2000-talet med avsändare som statsministrarna <strong>Göran Persson</strong> (s) och <strong>Stefan Löfven</strong> (s), näringsministrar som Maud Olofsson (c) och energiminister <strong>Mona Sahlin</strong> (s).</li>
<li>Det som låter för bra för att vara sant är ofta för bra för att vara sant. I nästa skede kollapsar fantasiprojektens glädjekalkyler under de mer svårflörtade ekonomiska och teknologiska realiteterna.</li>
<li>Därefter följer en utdragen process av städning, nedskrivningar och hantering av kostnaderna, inte sällan har de direktörer, politiker och forskare som skapade bubblan då gått vidare till andra, mer lukrativa uppdrag. Fall av fusk och regelrätt korruption uppdagas också i det här skedet, men gissningsvis syns bara toppen av isberget.</li>
</ol>
<p>Förekomsten av stora mängder bidragspengar är en viktig orsak till att de gröna bubblorna växer och inte går att stoppa förrän det är för sent. Svenska politiker, oavsett regering, bär ett stort ansvar för den stödpolitik som har nått vägs ände. Som vi ser i figuren nedan har Energimyndighetens medel trefaldigats under 2000-talet. Ökningen har skett oavsett färg på regeringen, vilket understryker att det rör sig om ett systemfel.</p>
<figure id="attachment_92704" aria-describedby="caption-attachment-92704" style="width: 1255px" class="wp-caption alignnone"><img decoding="async" class="wp-image-92704 size-full" src="https://kvartal.se/wp-content/uploads/2023/04/G4.png" alt="" width="1255" height="751" data-wp-pid="92704" srcset="https://kvartal.se/wp-content/uploads/2023/04/G4.png 1255w, https://kvartal.se/wp-content/uploads/2023/04/G4-600x359.png 600w" sizes="(max-width: 1255px) 100vw, 1255px" /><figcaption id="caption-attachment-92704" class="wp-caption-text">Energimyndighetens omsättning i antal miljarder kronor om året.</figcaption></figure>
<p>Det bör dock i sammanhanget understrykas att EU förmodligen är den mest skyldiga. Tillväxten i alla bidrag, billiga lån och gratispengar som har ägt rum sedan finanskrisen har skapat en guldgruva för bidragsentreprenörer.</p>
<p>Trots att den gröna bidragskapitalismen skapat så många bubblor ser vi inga tecken på att den mattats av eller att vi lärt oss av historien. Tvärtom har främst EU ställt ännu större syltburkar med bidragspengar till näringslivets förfogande.</p>
<blockquote><p>Tyvärr verkar inte 2000-talets gröna bubblor ha lett till någon rannsakan.</p></blockquote>
<p>Ingen forskare har haft större inflytande över EU:s nya ”gröna” industripolitik än den italiensk-amerikanska kändisekonomen <strong>Mariana Mazzucato</strong>. Hennes forskargrupp har haft stort inflytande över EU:s <em>Green Deal</em> och alla de stödprogram som sjösatts. ”Mazzucato-rapporten” presenterades i februari 2018 och lade upp riktlinjerna för implementeringen av denna politik inom EU. Mazzucatos grupp gick ett steg längre i sin rapport för EU-kommissionen från 2022:</p>
<p>”Public authorities must steer investment-led economic development across many different sectors and instead of picking the winners, governments should rather support the “willing” and the “innovative”, those companies willing to partner, transform and innovate towards the new green and social paradigm”<sup>1</sup></p>
<h2>Gröna bubblor i Norrland?</h2>
<p>Den ”gröna boomen” som kan ses i Norrland idag bör skärskådas i ljuset av alla misslyckade gröna satsningar under 2000-talet och de enorma mängderna EU-pengar som flödar ut från olika bankkonton i Bryssel.</p>
<p>Projekten bygger ofta på enastående esoteriska, vidlyftiga planer på att använda nya teknologier för förment grön omställning som kombineras med retorik om att vara ”världsledande”, ”behålla ledartröjan i det globala racet” och liknande på ett sätt som borde stämma till eftertanke.</p>
<ul>
<li>I avfolkningskommunen Ånge planeras en satsning på två vätgasfabriker. Företaget RES Renewable Norden har för avsikt att leverera grön vätgas till industrin inom några år.</li>
<li>Uniper och Sasol ecoFT skrev en avsiktsförklaring tillsammans med Sollefteå kommun om att företagen skulle undersöka möjligheten till etablering av SkyFuelH2 i Långsele. Dåvarande näringsminister <strong>Karl-Petter Thorwaldsson</strong> var på plats i Långsele och var redo att ösa beröm över ansökan där man också ville ha medfinansiering från Energimyndigheten på 261 miljoner kronor. Man talar om möjligheter till 100 nya arbetstillfällen.</li>
<li>SCA har planer för att bygga 4 500 vindkraftverk i Västernorrland. Vilken total kostnad detta innebär för skattebetalarna via kostnader för kablage och störningar på elsystemet är det ingen som vet.</li>
<li>Gotlandsbolaget lanserar ett <a href="https://www.hamnen.se/artiklar/reportage/nya-gotlandsfarjan-gor-35-knop-pa-vatgas/">konceptfartyg</a> vid namn Gotland Hydrocat som man menar är världens första katamaran som går på vätgas.</li>
<li>Göteborgs Hamn planerar för egen vätgasproduktion och beräknas <a href="https://dagenslogistik.se/goteborgs-hamn-planerar-for-vatgasproduktion/">starta produktion</a> i mitten av 2023.</li>
<li>I Stockholm har H2 Green Steel ordnat finansiering från Europeiska Investeringsbanken för att göra stål med hjälp av vätgas i Boden. Varken tillgång till elektricitet, järnmalm eller någon produktionsanläggning behövs för att få en kreditlina på flera miljarder euro från företrädesvis offentliga finansiärer. Bolagets vd Henrik Henriksson <a href="https://www.di.se/debatt/debatt-ska-statligt-stod-betalas-ut-for-att-stalla-om-stalindustrin/">skriver</a> på DI Debatt den 13 februari och ber om miljarder i bidrag.</li>
<li>Hybrit-projektet där LKAB, SSAB och Vattenfall ska ta motsvarande hela Finlands elanvändning i anspråk för att göra stål med hjälp av vätgas. På upprepade <a href="https://www.di.se/debatt/debatt-fragan-kvarstar-hur-ska-ni-fa-el/">frågor</a> om varifrån elektriciteten ska komma har svaren än så länge lyst med sin frånvaro. Man har än så länge <a href="https://www.nationalekonomi.se/sites/default/files/2022/11/51-1-mhcs.pdf">kammat hem pengar</a> i flera vändor från olika statliga finansiärer: 528 miljoner från Energimyndigheten 2018, 47 miljoner från Energimyndigheten 2019 för vätgaslager, 1,4 miljarder från EU 2022. Dessa medel har kombinerats med de tre statliga bolagens egna medel, som ytterst hade kunnat användas till alternativa ändamål såsom att delas ut till staten och medborgarna.</li>
</ul>
<p>En viktig orsak till att ”grönt” stål fått så mycket uppmärksamhet är mängden pengar som tillgängliggjorts på EU-nivå för just stålproduktion. Dessa pengar kanaliseras sedan till medlemsländerna som får i uppgift att kombinera EU-medlen med nationella pengar i olika programsatsningar. I Sverige är Energimyndighetens ”Industriklivet” och Naturvårdsverkets ”Klimatklivet” exempel på sådana satsningar. Figuren nedan visar hur stor del av dessa resurser som varit öronmärkta för just järn och stål.</p>
<p><img decoding="async" class="wp-image-92705 size-full" src="https://kvartal.se/wp-content/uploads/2023/04/G5.png" alt="kvartal" width="1092" height="676" data-wp-pid="92705" srcset="https://kvartal.se/wp-content/uploads/2023/04/G5.png 1092w, https://kvartal.se/wp-content/uploads/2023/04/G5-600x371.png 600w, https://kvartal.se/wp-content/uploads/2023/04/G5-300x186.png 300w, https://kvartal.se/wp-content/uploads/2023/04/G5-768x475.png 768w" sizes="(max-width: 1092px) 100vw, 1092px" /></p>
<p>Tyvärr verkar inte 2000-talets gröna bubblor ha lett till någon rannsakan. Utvärderingar har ofta varit partsinlagor, där såväl forskare som konsultföretag är försatta i en beroendesituation i förhållande till politiker och myndigheter. Sekab-härvan i Örnsköldsvik understöddes av uppåt en miljard från Energimyndigheten, som i sin årsredovisning 2011 skrev följande om denna satsning:</p>
<p>”Detta var ett excellent program och en fortsättning på en nivå som är åtminstone lika hög som under de gångna åren rekommenderas starkt.”</p>
<p>Man hänvisar till en vetenskaplig utvärdering, men någon referens eller källa går inte att finna.</p>
<p>Alla satsningar som pågår i Norrland måste tyvärr nagelfaras ordentligt mot bakgrund av 2000-talets tragiska följetong av gröna bubblor. Hundratals miljarder av bidragspengar har ställts till förfogande för vinstmaximerande företag, vilket leder till en utbredd och storskalig bidragskapitalism där ex-politiker, riskkapitalister och storbolag gör gemensam sak genom så kallad ”samverkan”. Kostnaderna lämpas sedan över på skattebetalarna i form av högre skatter och sämre service under en lång tid.</p>
<p>Utöver en ordentlig skärskådning av det som pågår i Norrland vore en oberoende haverikommission gällande alla misslyckade satsningar på förment ”gröna” satsningar på sin plats.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="92685">  <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>Mariana Mazzucato &amp; Rainer Kattel &amp; Josh Ryan-Collins. “Challenge-Driven Innovation Policy: Towards a New Policy Toolkit”, Journal of Industry, Competition and Trade, 26 December 2019 <a href="https://doi.org/10.1007/s10842-019-00329-w">https://doi.org/10.1007/s10842-019-00329-w</a></li>
</ol>
</div>
</div>
<div class="author-byline">Christian Sandström är biträdande professor, Jönköping International Business School och Ratio. Han doktorerade på Chalmers Tekniska Högskola 2010 där han även blev docent 2014. Han har bland annat forskat vid universitetet i Cambridge.
</div>
</div>
