I korthet
För över en miljon svenskar är det ett fritidsintresse, på matbordet är det en svensk kulturbärare, för renägande samer en rättighet och för ägarna till cirka tusen fiskebåtar ett yrke – samtidigt avlöser larmen varandra i medierna. Hur mår egentligen fisken i svenska vatten?
<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-117317"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-pid="117317" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci8xMS00Mi1zYS1tYXItZmlza2VuLWktc3ZlbnNrYS12YXR0ZW4ubXAz" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvMTEtNDItc2EtbWFyLWZpc2tlbi1pLXN2ZW5za2EtdmF0dGVuLm1wMw==">  <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/carl-axel-fall/">Carl-Axel&nbsp;Fall</a> | 30 december 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%2Fsa-mar-fisken-i-svenska-vatten%2F&amp;t=S%C3%A5+m%C3%A5r+fisken+i+svenska+vatten"    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=S%C3%A5+m%C3%A5r+fisken+i+svenska+vatten+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-mar-fisken-i-svenska-vatten%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%2Fsa-mar-fisken-i-svenska-vatten%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så mår fisken i svenska vatten&body=https://kvartal.se/artiklar/sa-mar-fisken-i-svenska-vatten/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/117317/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/117317/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%2Fsa-mar-fisken-i-svenska-vatten%2F&amp;t=S%C3%A5+m%C3%A5r+fisken+i+svenska+vatten"    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=S%C3%A5+m%C3%A5r+fisken+i+svenska+vatten+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fsa-mar-fisken-i-svenska-vatten%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%2Fsa-mar-fisken-i-svenska-vatten%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Så mår fisken i svenska vatten&body=https://kvartal.se/artiklar/sa-mar-fisken-i-svenska-vatten/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/117317/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/117317/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/sa-mar-fisken-i-svenska-vatten/?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 13 min</span></a><a href   = "https://kvartal.se/skarmlasarvanlig/117317"    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-117317">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "117317"></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 ">För över en miljon svenskar är det ett fritidsintresse, på matbordet är det en svensk kulturbärare, för renägande samer en rättighet och för ägarna till cirka tusen fiskebåtar ett yrke – samtidigt avlöser larmen varandra i medierna. Hur mår egentligen fisken i svenska vatten?</p>
</div>
<div class="rest-of-article ">Följ med på en tur som slingrar sig mellan allvarliga hot, men också en del hoppingivande nyheter. Varje vatten är översiktligt betygsatt utifrån några viktiga arter från 1 och kris till fina fisken 5.<sup>1</sup></p>
<h2>Västerhavet: 3</h2>
<h2><img decoding="async" class="alignnone wp-image-117342" src="https://kvartal.se/wp-content/uploads/2023/12/3-1.png" alt="" width="67" height="67" data-wp-pid="117342" srcset="https://kvartal.se/wp-content/uploads/2023/12/3-1.png 172w, https://kvartal.se/wp-content/uploads/2023/12/3-1-150x150.png 150w" sizes="(max-width: 67px) 100vw, 67px" /></h2>
<p>En av de mer sensationella förändringarna som skett i svenska vatten är återkomsten av blåfenad tonfisk. Spolformade bjässar på 300 kilo kommer in till Västkusten i stora stim och tar för sig av makrill och näbbgädda.</p>
<p>Fram till 1960-talet var den en vanlig syn under sensommaren och hösten. Sedan tynade beståndet bort och det var ingen som väntade att tonfisken skulle komma tillbaka.</p>
<p>Fiskekvoterna sänktes varje år. Men utan förbättring. Så infördes rödlistning och 2010 ett totalt fiskestopp. Då vände det förhållandevis snabbt.</p>
<p>Turistnäringen jublar över tillresande tonfiskskådare.</p>
<p>För att ett vatten ska ha ett balanserat ekosystem krävs fiskar av alla slag, från minsta spigg till stora rovfiskar.</p>
<p>Att tonfisken är tillbaka tyder på att hälsan i Västerhavets fiskbestånd förbättrats. Också andra rovfiskar har repat sig, till exempel pigghajen som varit borta i 40 år. Men för torsken är det sedan länge mycket illa. Och torsken är den art som varit viktigast för människan.</p>
<h2>Centrala Östersjön: 2</h2>
<h2><img decoding="async" class="alignnone wp-image-117344" src="https://kvartal.se/wp-content/uploads/2023/12/2.png" alt="" width="73" height="73" data-wp-pid="117344" srcset="https://kvartal.se/wp-content/uploads/2023/12/2.png 172w, https://kvartal.se/wp-content/uploads/2023/12/2-150x150.png 150w" sizes="(max-width: 73px) 100vw, 73px" /></h2>
<p>Det är i Östersjön som den kanske största dramatiken utspelar sig under ytan.</p>
<p>Torskbeståndet är i det närmaste utslaget, även om det i centrala Östersjön finns rester kvar är fisken i mycket dålig kondition. Torsken stannar i dvärgformat.</p>
<p>Dödskraschen för torsken i Östersjön kan dateras till 2019 efter överfiske åren innan.</p>
<p>En strimma av hopp kan möjligen knytas till ett forskningsprojekt kring odling av det småväxta torskbeståndet i centrala Östersjön som drivs av Lantbruksuniversitetet och Baltic Waters, en privat finansierad stiftelse där forskare och människor med näringslivsbakgrund samverkar.</p>
<p>I två år har forskningsstationen på Gotland fått fångade torskar att leka. Deras larver har växt till helt normalt och de har som nykläckta satts ut på lämpliga ställen.</p>
<p>Nu är många oroliga för att sillen ska gå samma väg som torsken. (Sill och strömming är samma art, norr om Kalmarsund kallas den strömming.) Sillen är själva motorn i Östersjöns ekosystem och en krasch skulle vara förödande för hela ekosystemet.</p>
<p>Nu är spiggen, den cirka 5–6 cm långa fisken som syns på badplatserna på sommaren, mycket vanlig i hela Östersjön och kan utgöra en femtedel av all fiskbiomassa där. Den rör sig i enorma stim i de fria vattnen när den inte uppsöker stränderna. Spiggen äter djurplankton i stor mängd, vilket resulterar i att slemmiga alger kan breda ut sig, eftersom djurplanktonen inte längre betar ner dem. Spiggen äter därtill också ägg och yngel av abborre, gädda och strömming.</p>
<p>För att stärka strömmingsbeståndet skulle man kunna fiska spigg. Provfiske<span style="color: #0000ff;"><strong> </strong></span>med industritrålare har gjorts i Baltic Waters regi. Men försöken slog inte väl ut, det var svårt att lokalisera spiggen och få fisket lönsamt. Det anses också tveksamt om detta är rätt väg att skapa balans mellan arterna.</p>
<p>Fisket i Östersjön regleras varje år av EU. I botten jobbar ett internationellt forskarteam, ICES,<sup>2</sup> som ger rekommendationer till EU-kommissionen. ICES anger ett intervall med ett lägre och ett högre värde för kvoterna. Efter kommissionens beredning träder EU:s ministerråd in med beslut. Historiskt har ICES ofta blivit överkörda av EU:s politiker.</p>
<p>Resultatet har blivit ett politiskt beslutsfattande som tenderar att ligga efter, så som skedde när torsken kollapsade.</p>
<p>Inför årets förhandlingar fanns det sedan länge ett hårt tryck från miljöorganisationer som WWF, Naturskyddsföreningen och Sportfiskarna att få Bryssel att besluta om ett förbud mot allt strömming-/sillfiske i Östersjön.</p>
<p>När jag träffar landsbygdsminister <strong>Peter Kullgren</strong> (KD) strax före ministermötet är han klar över att han vill bevara det småskaliga kustnära fisket. Han säger också att EU-kommissionens förslag om stopp för allt riktat fiske efter sill inte får stöd av något annat land, och att spela vid sidan om andra nationer riskerar att ge ett sämre resultat. Regeringen förlitar sig på ICES forskning och kommer åberopa deras lägsta siffror.</p>
<p>Ministerrådets beslut för sillen i Östersjön blev till slut påtagligt sänkta kvoter, från 150 000 ton för 2023 till 95 000 ton 2024 för de två viktigaste områdena. Det är cirka 5 procent över ICES lägsta gräns inom det intervall som de uppskattar att fisket kan ske inom. Det betyder i praktiken att det småskaliga kustnära fisket för människoföda kan fortsätta och att industrifisket får kvoter som tillåter sill som bifångst.</p>
<p><strong>Anton Paulrud</strong>, talesperson för de stora trålfiskarnas organisation Pelagikerna, menar att sedan sillkvoterna sänktes rejält 2019 har sillbeståndet längs södra ostkusten klarat sig ganska bra. Att strömmingsfisket var dåligt i norr i maj och juni i år berodde på att vattnet blev för varmt och strömmingen drog sig mot Finland. Han tycker att EU skulle ha beslutat om ICES högsta gränsvärde.</p>
<p>Forskare gör en helt annan bedömning. <strong>Henrik Svedäng</strong> på Östersjöcentrum vid Stockholms universitet är en forskare som länge följt torsk- och sillpopulationerna. Han anser att läget för sillen är akut. ”I det läget kan man inte ta hänsyn till om några fiskeföretagare går omkull.”</p>
<p>Han vill se ett fiskeförbud för allt fiske efter sill för hela Östersjön och hävdar att fiskestopp oftast fungerar för att stärka bestånd. Från Norge finns det flera goda exempel på det.</p>
<p>Också Baltic Waters vill reglera hårdare. Ordförande <strong>Konrad Stralka</strong> påpekar att skarpsillen, som mestadels går till djurfoder, tål fiske men bifångsterna av sill blir så stora att sillbeståndet hotas hur man än gör. ”Därför är det enda raka att förbjuda de stora trålarna. Vi vill ha kvar det kustnära småskaliga fisket, det är lättare att kontrollera.”</p>
<p>På frågan om hur regeringens kommande politik för trålfisket ser ut svarar landsbygdsminister Peter Kullgren att regeringen gett klartecken till Havs- och vattenmyndigheten att på försök flytta ut trålgränsen till tolv nautiska mil på vissa områden. Försöket ska pågå till 2027.</p>
<p>Anton Paulrud är orolig att regeringen kan komma att flytta ut trålningsgränsen lite överallt längs hela kusten. Det blir i princip ett förbud mot trålning. ”Med ett förbud skulle företagen vara borta på ett par år och även förädlingsindustrin. ”För att ha kvar den måste vi ha stora fartyg.”</p>
<p>Nyligen kom Världsnaturfonden, WWF, med en rekommendation till konsumenter att undvika att äta strömming från Östersjön då bestånden bedöms vara under gränsen för återhämtning.</p>
<p>Strax efter beslutet i Bryssel om fortsatt sillfiske deklarerade Miljöpartiet att det skulle anmäla regeringen och kommissionen till EU-domstolen för att beslutet strider mot EU:s fiskeförordningar. Förordningarna har funnits sedan 2017 men aldrig tidigare åberopats.</p>
<h2>Öresund: 3</h2>
<h2><img decoding="async" class="alignnone wp-image-117342" src="https://kvartal.se/wp-content/uploads/2023/12/3-1.png" alt="" width="76" height="76" data-wp-pid="117342" srcset="https://kvartal.se/wp-content/uploads/2023/12/3-1.png 172w, https://kvartal.se/wp-content/uploads/2023/12/3-1-150x150.png 150w" sizes="(max-width: 76px) 100vw, 76px" /></h2>
<p>I Öresund är fiskförhållandena ganska hyggliga. Här finns ett lokalt torskbestånd efter att olika åtgärder satts in. Viktigast är nog det trålningsförbud som gällt sedan 1932. Det infördes inte för att värna om fisken utan för att det ansågs för farligt med trålare i ett så tätt trafikerat vatten. 2022 infördes ett nytt fiskeförbud på torsk under lektiden och 2024 förbjuds allt fritidsfiske efter torsk i Öresund. Ett visst yrkesfiske efter torsk får ske medan det upphört för hela Östersjön och Kattegatt. Det enda svenska havsområde där riktat fiske efter torsk ännu bedrivs är Skagerack.</p>
<h2>Ostkustens skärgård: 2</h2>
<h2><img decoding="async" class="alignnone wp-image-117343" src="https://kvartal.se/wp-content/uploads/2023/12/1.png" alt="" width="63" height="63" data-wp-pid="117343" srcset="https://kvartal.se/wp-content/uploads/2023/12/1.png 172w, https://kvartal.se/wp-content/uploads/2023/12/1-150x150.png 150w" sizes="(max-width: 63px) 100vw, 63px" /></h2>
<p>Förut hade ställen som Stockholms skärgård ett makalöst gäddfiske. Men nu är gäddan borta från stora områden i skärgården, med undantag av mindre lokala bestånd i delar som ligger avskärmade från havet. Numera skyddas många sträckor från sportfiske hela eller delar av året. Kustnära våtmarker restaureras så att de ska hålla vatten på vårarna för att gäddan ska kunna reproducera sig. Prognosen pekar mot en långsam förbättring. Om det blir hållbart beror troligen på om strömmingen ute till havs repar sig.</p>
<h2>Blekinge/Kalmar: 2</h2>
<h2><img decoding="async" class="alignnone wp-image-117344" src="https://kvartal.se/wp-content/uploads/2023/12/2.png" alt="" width="73" height="73" data-wp-pid="117344" srcset="https://kvartal.se/wp-content/uploads/2023/12/2.png 172w, https://kvartal.se/wp-content/uploads/2023/12/2-150x150.png 150w" sizes="(max-width: 73px) 100vw, 73px" /></h2>
<p>Runt Sveriges sydöstligaste hörn samlas ålar i sin vandring till lekplatserna i Sargassohavet. Ålfisket har gamla traditioner och ålgarnen har legat tätt här i generationer. Efter en kraftig nedgång av beståndet infördes fiskeförbud, men det fick dålig efterlevnad. Havs- och vattenmyndigheten tillsatte sent omsider fisketillsyningsmän för att stävja tjuvfisket. Under åren 2021–2022 upptäckte de 309 tjuvfiskande fiskeredskap. En som blev påkommen var dåvarande statssekreteraren <strong>PM Nilsson</strong>. Ålens utveckling är en tragedi om man ser till vad den en gång betytt i Sverige.</p>
<p>Ålen vandrade upp i åar, älvar och bäckar i hela landet och betydde mycket för folkhushållet.</p>
<p>Ett hot hittar vi i vattenkraftverken som stänger av ålens vandringar från sjöar och vattendrag till havet.</p>
<p>Ålen är inte utdöd, men hårt ansatt. Beståndet hålls vid liv genom räddningsinsatser. Små ålyngel, glasålar, fångas vid vissa vattendrag i Europa.</p>
<p>Ynglen flygs till flodmynningar i Sverige för utsättning. De vandrar upp i vattendragen, men när de ska vandra ner för lek blir de ofta sönderhackade i kraftverkens turbiner. Insatser har gjorts där utvandringsmogna ålar flugits med helikopter till havet.</p>
<p>Men metoden är omstridd. Henrik Svedäng anser att det är galenskap att göra utsättningar i sötvatten eftersom ålen skulle klara att växa upp i Östersjön. Den kan leva och växa sig lekmogen i mindre salta hav som Östersjön. Merparten av all ål som naturligt kommer till svenska vatten vandrar inte heller upp i sötvatten.</p>
<p>Forskningsrådet Formas gör nu en omfattande internationell utredning som ska ligga till grund för en ny svensk ålplan som ska godkännas av EU.</p>
<figure id="attachment_117350" aria-describedby="caption-attachment-117350" style="width: 1024px" class="wp-caption alignnone"><img decoding="async" class="wp-image-117350 size-full" src="https://kvartal.se/wp-content/uploads/2023/12/sdltG1aKFDwpIE-nl.jpg" alt="" width="1024" height="798" data-wp-pid="117350" srcset="https://kvartal.se/wp-content/uploads/2023/12/sdltG1aKFDwpIE-nl.jpg 1024w, https://kvartal.se/wp-content/uploads/2023/12/sdltG1aKFDwpIE-nl-600x468.jpg 600w, https://kvartal.se/wp-content/uploads/2023/12/sdltG1aKFDwpIE-nl-300x234.jpg 300w, https://kvartal.se/wp-content/uploads/2023/12/sdltG1aKFDwpIE-nl-768x599.jpg 768w" sizes="(max-width: 1024px) 100vw, 1024px" /><figcaption id="caption-attachment-117350" class="wp-caption-text"><em>Ett sista hurra? Team Karlskronafiske på SM i gäddfiske 2016. Foto: Privat/Sportfiskarna.</em></figcaption></figure>
<p>I Blekinge fanns fram till en bit in på 2000-talet ett unikt storvuxet gäddbestånd som lockade sportfiskare från hela landet. När torsken tog slut i området riktade några yrkesfiskare in sig på gädda. Inga restriktioner fanns.</p>
<p>Yrkesfiskarna hittade avsättning för fisken i Frankrike. Runt 2016 var överfisket ett faktum och beståndet minskade kraftigt. Därefter har nya fredningsområden skapats. Länsstyrelserna i Kalmar och Blekinge tycker sig nu se en positiv trend. ”Fredningsområden fungerar”, säger <strong>Martin Stålhammar</strong>, fiskekonsulent på länsstyrelsen i Blekinge.</p>
<h2>Bottenhavet och<span style="color: #0000ff;"><strong> </strong></span>Bottenviken: 3</h2>
<h2><img decoding="async" class="alignnone wp-image-117342" src="https://kvartal.se/wp-content/uploads/2023/12/3-1.png" alt="" width="77" height="77" data-wp-pid="117342" srcset="https://kvartal.se/wp-content/uploads/2023/12/3-1.png 172w, https://kvartal.se/wp-content/uploads/2023/12/3-1-150x150.png 150w" sizes="(max-width: 77px) 100vw, 77px" /></h2>
<p>Längs Norrlandskusten har strömmingen minskat till den grad att surströmmingsnäringen stått utan fisk. I våras var rapporterna många och mycket alarmerande.</p>
<p>Kommissionens beslut i Bryssel nyligen blev att sillfisket i Bottenhavet och Bottenviken ska minskas med 31 procent nästa år.</p>
<p>Fisket efter siklöja är dock mycket lönsamt och lax och öring har ökat under senare år.</p>
<h2>Inlandsvatten: 2–5</h2>
<h2><img decoding="async" class="alignnone wp-image-117344" src="https://kvartal.se/wp-content/uploads/2023/12/2.png" alt="" width="97" height="97" data-wp-pid="117344" srcset="https://kvartal.se/wp-content/uploads/2023/12/2.png 172w, https://kvartal.se/wp-content/uploads/2023/12/2-150x150.png 150w" sizes="(max-width: 97px) 100vw, 97px" /><img decoding="async" class="alignnone wp-image-117342" src="https://kvartal.se/wp-content/uploads/2023/12/3-1.png" alt="" width="102" height="102" data-wp-pid="117342" srcset="https://kvartal.se/wp-content/uploads/2023/12/3-1.png 172w, https://kvartal.se/wp-content/uploads/2023/12/3-1-150x150.png 150w" sizes="(max-width: 102px) 100vw, 102px" /> <img decoding="async" class="alignnone wp-image-117345" src="https://kvartal.se/wp-content/uploads/2023/12/4-1.png" alt="" width="99" height="99" data-wp-pid="117345" srcset="https://kvartal.se/wp-content/uploads/2023/12/4-1.png 172w, https://kvartal.se/wp-content/uploads/2023/12/4-1-150x150.png 150w" sizes="(max-width: 99px) 100vw, 99px" /><img decoding="async" class="alignnone wp-image-117346" style="font-size: 16px;" src="https://kvartal.se/wp-content/uploads/2023/12/5.png" alt="" width="102" height="102" data-wp-pid="117346" srcset="https://kvartal.se/wp-content/uploads/2023/12/5.png 172w, https://kvartal.se/wp-content/uploads/2023/12/5-150x150.png 150w" sizes="(max-width: 102px) 100vw, 102px" /></h2>
<p>Det är för stor variation för att kunna ge inlandsvattnen ett enda betyg.</p>
<p>Det finns sjöar som är drabbade av industrigifter, mikroplaster och PFAS-ämnen. Och klimatförändringen kommer sannolikt att slå ut den kallvattenälskande rödingen från vatten söder om Dalarna.</p>
<p>Men den största fiskvårdsfrågan i inlandsvattnen handlar om att öppna vandringsvägar så att fisk, och andra djur, kan vandra till olika vattenmiljöer.</p>
<p>1983 var vattenkraftsutbyggnaden definitivt slut. Miljörörelsen inriktade sig på att reparera skadorna. Man ville åter få fisk i älvarna. Med omlöp eller så kallade faunapassager (fisktrappor) skulle fisken kunna vandra runt kraftverken och nå fler platser för lek. Låsningarna var dock stora mellan kraftverksintressenter, miljörörelse och myndigheter. Så kom EU:s relativt skarpa vattendirektiv 2001. Det krävde att alla vattenkraftverk skulle miljöprövas utifrån ett strikt regelverk. De som inte var samhällsekonomiskt lönsamma skulle rivas och övriga skulle uppnå en God Ekologisk Potential, GEP. Det tog 19 år innan EU:s ambition började synas i svensk politik. Regeringen Löfvén antog i juni 2020 den Nationella Planen för omprövning (NAP) av vattendomarna för Sveriges alla kraftverk. 1 800 kraftverk ska miljöprövas i domstol.</p>
<p>Strax före valet 2022 hävdade Fortum att NAP behövde pausas. Det blev sedan ett vallöfte från Tidöpartierna. Kort tid efter valet meddelade regeringen att genomförande av NAP skulle flyttas fram ett år.</p>
<p>Nu måste alltså regeringen komma med något som ger riktning för framtiden. Blir det verkligen några nya moderna miljövillkor för vattenkraften?</p>
<p>Enligt Regeringskansliet kommer miljöprövningen inte att avskaffas och planen är att de nya förutsättningarna ska vara på plats till den 1 februari. Det blir en del ändringar i regler och författningar.</p>
<p>Miljöprövningen av vattenkraften sorterar under miljöminister <strong>Romina Pourmokhtari</strong> (L). Liberalerna röstade tidigare rödgrönt i denna fråga men gick senare in i Tidöavtalet.</p>
<p>På Klimat- och näringslivsdepartementet<span style="color: #0000ff;"><strong> </strong></span>tycker man att kraftbolagen och Svenska Kraftnät har varit lite väl avvaktande hittills i samverkansprocessen.</p>
<p>Men bolagen lär inte kunna slippa undan. Den gamla juridiken kring vattendomar är överspelad och behöver förnyas.</p>
<p>Att bygga omlöp är ingen billig sak. Det nyligen invigda omlöpet vid Spjutmo kraftstation i Österdalälven uppges ha kostat 100 miljoner kronor.</p>
<p>Det finns nu en färdig överenskommelse att kraftbolagen ska betala tio miljarder kronor till en miljöfond. I utbyte får de mindre krav på miljöanpassningar i de stora norrlandsälvarna.</p>
<p>Enligt EU ska åtgärderna vara genomförda 2027. Det kommer Sverige med sina många vattenkraftverk inte att klara. På regeringskansliet hoppas man undvika EU-böter genom att visa att frågan ändå har gott driv.</p>
<h2>Fjällvattnen</h2>
<p><img decoding="async" class="alignnone wp-image-117499" src="https://kvartal.se/wp-content/uploads/2023/12/Same-1-kopia-287x300.jpg" alt="" width="131" height="137" data-wp-pid="117499" srcset="https://kvartal.se/wp-content/uploads/2023/12/Same-1-kopia-287x300.jpg 287w, https://kvartal.se/wp-content/uploads/2023/12/Same-1-kopia.jpg 342w" sizes="(max-width: 131px) 100vw, 131px" /></p>
<p>Den mest brännande frågan kring fisket i fjälltrakterna är vem som ska ha rätt att fiska i områden som ligger inom samebyarna. Där finns en del riktigt goda fiskevatten. Mycket uppmärksammad blev domen om Girjas sameby i januari 2020, som tilldömdes rätten att bestämma över fiske och jakt inom dess vida gränser. Nu gäller att enbart samer som är medlemmar i samebyn får fiska och länsbor bokförda i Norrbotten kan köpa rätt, inga andra. Undantaget är en fiskecamp som fått samernas rätt att sälja exklusivt fiske till den som kan betala.</p>
<p>Efter domen tillsatte gamla regeringen den så kallade Renmarkskommittén för en utredning. En första rapport har presenterats, men utredarna blev inte eniga och kom inte med något förslag. Den uttalade dock att det är samerna som av urminnes hävd har rätt att bestämma över jakt och fiske ovan odlingsgränsen i Lappland på statlig mark.</p>
<p>”Det här är en oerhört infekterad fråga”, säger landsbygdsminister Peter Kullgren, som lagt till nya direktiv till utredningen. Han hoppas på avvägningar som ger så många som möjligt möjlighet att vistas i vår natur för rekreation, som fiske eller jakt. Kullgren är tydlig med att den svenska naturen är allas. Där ligger knäckfrågan.</p>
<p>Det finns en utbredd rädsla i norr att samebyarna ska lägga beslag på fisket genom att hävda att fiskare och jägare stör renarna. Norrlänningarna bor i samma landskap som den lilla renägande samiska minoriteten och de delar alla andra rättigheter och skyldigheter, men de renägande samerna kan få en exklusiv rätt att bestämma över fisket och jakten, något som är en livsstil för långt fler än de renägande samerna. Här finns en källa för skarpa konflikter.</p>
<p>Nu ligger hela beslutsapparaten och väntar på hur fortsättningen ska bli när andra samebyar ansöker om samma rättigheter som i Girjas.</p>
<p>Nyligen framkom att Renmarkskommittén kört fast. S, V, C, MP och L stödjer en linje som innebär en fortsättning på Girjasdomen. Tidöpartierna går emot. Justitierådet <strong>Eric M Runesson</strong> som är kommitténs ordförande bekräftar för DN (19/12, 2023) att hans arbete är under diskussion i regeringen.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="117317">  <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, Fiskepopulationer går upp och ner, forskarna blir inte sällan överraskade av naturens nycker.<br />
Men med ny teknik blir forskarna allt säkrare på hur det ser ut i fisksamhället. Detta är en grov översiktsbedömning utifrån några viktiga arter.</p>
<p>Bottenhavet/Bottenviken: 3. Sill/Strömming=2, Skarpsill=4, Siklöja=4, Lax och Öring=3</p>
<p>Östersjön centrala: 2. Sill/Strömming=2, Torsk=1, Skarpsill=4</p>
<p>Ostkustens skärgård: 1. Strömming=2 finns fläckvis, Torsk=1, Gädda/Abborre 1–3</p>
<p>Blekinge/Kalmar: 2. Ål=2, Sill=1–2, Skarpsill=3, Torsk=1, Gädda=1</p>
<p>Öresund: 3. Torsk=3, Sill=2, Makrill=5</p>
<p>Västerhavet: 3. Sill=3, Torsk=2, Skarpsill=4, Makrill=5</p>
<p>Inlandsvattnen: 2–5. Stor variation</p>
<p>&nbsp;</p>
<p>2, ICES Internationella Havsforskningsrådet (International Council for the Exploration of the Sea)</p>
<p>Organisation som samordnar och främjar havsforskning i Östersjön och Nordatlanten. ICES förslag till fiskekvoter sätts i intervall med en lägsta och en högsta nivå. Det finns också EU-lagar som reglerar fisket. De har dock aldrig tillämpats i fiskeförhandlingarna.</p>
</div>
</div>
<div class="author-byline">Carl-Axel Fall, journalist och tidigare chefredaktör för Naturskyddsföreningens tidning Sveriges natur.
</div>
</div>
