Ett historiekrig väntar
om de svenska fjällen

<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-162426"      class = "kv-pod-holder kv-player-light  lplo " data-sid="" data-eid="" data-tis="1077" data-tin="1194" data-pid="162426" data-pty="SW5sw6RzdCBhcnRpa2VsIChTYW1ow6RsbGUp" data-pna="RXR0IGhpc3Rvcmlla3JpZyB2w6RudGFyPGJyPm9tIGRlIHN2ZW5za2EgZmrDpGxsZW4=" data-acurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2UvaW5sYXN0YXRleHRlci84LTQ5LWV0dC1oaXN0b3JpZWtyaWctdmFudGFyLW9tLWRlLXN2ZW5za2EtZmphbGxlbi5tcDM=" data-psurl="aHR0cHM6Ly9tZWRpYS5wb2Quc3BhY2Uva2p4ajYzeWRkZXEydmgvOC00OS1ldHQtaGlzdG9yaWVrcmlnLXZhbnRhci1vbS1kZS1zdmVuc2thLWZqYWxsZW4ubXAz">  <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%2Fett-historiekrig-vantar-om-de-svenska-fjallen%2F&amp;t=Ett+historiekrig+v%C3%A4ntar%3Cbr%3Eom+de+svenska+fj%C3%A4llen"    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=Ett+historiekrig+v%C3%A4ntar%3Cbr%3Eom+de+svenska+fj%C3%A4llen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fett-historiekrig-vantar-om-de-svenska-fjallen%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%2Fett-historiekrig-vantar-om-de-svenska-fjallen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ett historiekrig väntar<br>om de svenska fjällen&body=https://kvartal.se/artiklar/ett-historiekrig-vantar-om-de-svenska-fjallen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/162426/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/2023/05/Goran-1.jpg');"></div><img class="author-print-img" src="https://kvartal.se/wp-content/uploads/2023/05/Goran-1.jpg" style="display: none;">    </div>    <div class="by-disclaimer-holder" style="color: #8a3a67">Av <a href="https://kvartal.se/medverkande/goran-frojdh/">Göran&nbsp;Fröjdh</a> | 5 mars 2025<div class="author-desc">Göran Fröjdh ä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%2Fett-historiekrig-vantar-om-de-svenska-fjallen%2F&amp;t=Ett+historiekrig+v%C3%A4ntar%3Cbr%3Eom+de+svenska+fj%C3%A4llen"    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=Ett+historiekrig+v%C3%A4ntar%3Cbr%3Eom+de+svenska+fj%C3%A4llen+-+https%3A%2F%2Fkvartal.se%2Fartiklar%2Fett-historiekrig-vantar-om-de-svenska-fjallen%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%2Fett-historiekrig-vantar-om-de-svenska-fjallen%2F"    target = "_blank"    class  = "li-link"    title  = "Dela på LinkedIn"><i class="ti-linkedin ui transparent"></i></a><a href    = "mailto:?subject=Ett historiekrig väntar<br>om de svenska fjällen&body=https://kvartal.se/artiklar/ett-historiekrig-vantar-om-de-svenska-fjallen/"   target  = "_blank"    class   = "pr-link"    title   = "E-posta"    onclick = ""><i class="ti-email ui transparent"></i></a><a href    = "https://kvartal.se/skriv-ut/162426/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/ett-historiekrig-vantar-om-de-svenska-fjallen/?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/fa6042ab-0830-4ac2-9693-e056d61c4d0f"    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-162426">  <div class="in-short-inner">    <span class="close_button close-in-short in-short-toggle" data-articleid = "162426"></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å känner nog till den så kallade Renmarkskommittén, en statlig utredning som satt i mer än tre år och därmed var en av de längsta genom tiderna. Den ursprungliga planen var att lämna slutbetänkande i vår, men i november lade landsbygdsminister <strong>Peter Kullgren</strong> ner kommittén i förtid.</p>
</div>
<div class="rest-of-article ">
<p>Motivet till nedläggningen var enligt Kullgren den massiva kritik som remissinstanserna riktat mot kommitténs delbetänkande.</p>
<p><i>”Det inkluderar bland annat kritik från myndigheter, kommuner, intresseorganisationer, samt samiska organisationer och representanter. Regeringen kommer därför inte att gå vidare med utredningens förslag”</i>, skrev Kullgren i det pressmeddelande som skickades ut i början av november.</p>
<p>Förslaget som kommittén lämnat hade visserligen minimala chanser att passera riksdagen. Men <em>om</em> det blivit lag hade det inneburit stora konsekvenser för invånarna i norra Sverige. Utredarens slutsats var nämligen att landets 43 fjäll- och skogssamebyar hade stöd i lagen för att få ensamrätt till jakt och fiske i fjällen. Alltså rättigheter som den svenska staten idag styr över och som omfattar stora delar av landet. Samebyarnas renskötsel bedrivs på nära halva Sveriges yta, även om utredningens förslag i första hand handlade om statens marker ovanför odlingsgränsen.</p>
<p>Men trots att utredningen lagts ner är chansen – eller risken beroende på vem man frågar – stor att just detta scenario blir verklighet till slut. Fem samebyar har stämt staten för att kräva ensamrätt till jakt och fiskerättigheter på sina renbetesmarker och fler ligger i startgroparna. Det första fallet, som gäller Talma sameby i Kiruna kommun, kommer sannolikt att tas upp i Gällivare tingsrätt senare i år, även om något datum ännu inte är satt.</p>
<p><b>Eric M Runesson</b>, justitieråd i Högsta domstolen som sitter på stol nummer 1 i Svenska Akademien, var ordförande för Renmarkskommittén. Han känner sig uppgiven och tycker att politikerna har misskött jakt- och fiskefrågan.</p>
<p>– Det är en olycka att politiken kapitulerat på det här sättet, säger han till Kvartal.</p>
<p>Vem som ska ensamrätt till jakten och fisket blir nu i stället upp till domstolarna att avgöra. Och Eric M Runesson är säker på att samebyarna kommer att få rätt till slut.</p>
<p>– Om inget nytt framkommer så kommer de att vinna mot staten, säger han.</p>
<p>Han får medhåll från <b>Jakob Heidbrink</b>, docent i juridik vid Göteborgs universitet, som säger till Kvartal att Renmarkskommitténs arbete utgör ett tungt vägande skäl till varför samebyarna kan komma att vinna mot staten.</p>
<p>– Kommittén kom fram till att omständigheterna för de olika samebyarna uppe i norr nog liknar det som Högsta domstolen kom fram till i det så kallade Girjasmålet år 2020, där Girjas sameby tilldömdes ensamrätten att upplåta jakt och fiske på statens marker ovanför odlingsgränsen. I och med det har samebyarna ett tungt argument i sina stämningar, säger Heidbrink.</p>
<div class = "kv-cruta closed grey cr-round "      id    = "cruta-jZMNkSWtYL"></p>
<h2><b>Stora värden står på spel</b></h2>
<p>Renskötseln tar stora landytor i anspråk och verksamheten har ofta krockat med turismen. 2023 stängde turistföreningen STF flera fjällstationer i Jämtland-Härjedalen, samtidigt som antalet besökare begränsades efter klagomål från samebyarna om att fjällvandrarna stört renarna.</p>
<p>Och det står stora värden på spel i fjällen. Naturtillgångarna i norr är av avgörande betydelse för inte bara Sveriges utan hela EU:s gröna omställning. Gruvor, vindkraftsparker, elintensiva industrier som stålverk, konstgödselfabriker och datahallar konkurrerar tillsammans med jakt- och fisketurismen om delvis samma utrymme som renskötseln.</p>
<p>I Balanskommissionens rapport <em>Markanvändning i Norrland</em> beräknas omsättningen för skogsindustrin till 20 miljarder kronor – 11 miljarder för jordbruk, skogsbruk och fiske samt 10 miljarder för kultur, nöje och fritid. Balanskommissionen är en påtryckningsgrupp för vad de kallar balans mellan ekonomiska intressen och miljö.</p>
<p>Enligt samma rapport uppgår rennäringens bidrag till svensk BNP till cirka 35 miljoner kronor och omsätter cirka 150 helårsarbetskrafter. I relation till hela ekonomin i de fyra nordligaste länen Norrbotten, Västerbotten, Jämtland och Västernorrland beräknas rennäringen stå för 0,01 procent av BNP.</p>
<p></div>
<h2><b>Utredarens ”bokslut” får hård kritik</b></h2>
<p>Några veckor efter att kommittén lades ner skrev Eric M Runesson ett ”bokslut” som lades ut på Renmarkskommitténs hemsida. Dokumentet innehöll ett utkast till färdig lagtext – där samebyarna återigen föreslås få ensamrätt till jakt och fiske i fjällmarkerna.</p>
<p>Publiceringen fick hård kritik eftersom texten inte granskats av vare sig utredningens expertgrupp, de sakkunniga eller politikerna.</p>
<p><b>Kjell-Arne Ottosson</b>, KD:s ledamot i kommittén, menar att den förre ordförandens tydliga ställningstagande kan riskera att påverka domstolarnas bedömning i de juridiska processer som pågår. Kommitténs arbete har redan åberopats av Talma sameby i dess stämningsansökan.</p>
<p>– Jag vet inte om det är hans mål att materialet, bland annat utkastet till lagtext, ska kunna användas i de processerna. Det är i vart fall ett märkligt agerande av ordföranden att lägga ut lagtextutkastet. Även om han är bitter och besviken så skulle han ha hållit sig för god att lägga ut det, säger Ottosson till tidningen Svensk Jakt.</p>
<p>Den kritiken förstår Eric M Runesson inte alls. I ett mejlsvar till Kvartal skriver han:</p>
<p><em>”Tja, det vore väl ännu märkligare om jag skulle ha låtit hundratals mantimmar av utfört arbete spårlöst gå upp i rök. Nu kan ju de klokare personer som ska ta vid bedöma om vårt arbete trots allt kan vara till någon användning och annars strunta i det. Det borde väl vara bra?”</em></p>
<div class = "kv-cruta closed grey cr-round "      id    = "cruta-nAICYUyzew"></p>
<h2>Samer och samebyar i Sverige</h2>
<p>Numera registreras inte etnisk tillhörighet i folkräkningarna, men enligt myndigheten Forum för levande historia beräknas antalet samer i Sverige vara mellan 20 000 och 50 000. Av dessa är cirka 10 procent medlemmar i en sameby.</p>
<p>Samtidigt är makten i dessa ekonomiska föreningar koncentrerad till ett 100-tal stora renägare. Detta beror i sin tur på att rösträtten i en sameby utgår från antalet ägda renar som en medlem har. Den som äger tusen renar har alltså tio gånger starkare rösträtt än den som har hundra, noterar<b></b> samen <strong>Ronny Svarto </strong><a href="https://kvartal.se/artiklar/fa-av-oss-samer-vagar-utmana-renagarnas-privilegier/">(Kvartal 10 oktober 2024)</a>, som menar att systemet skapat ett orättvist klassamhälle där majoriteten av samer och andra i ortsbefolkningen saknar inflytande.</p>
<p></div>
<p>Efter Girjasdomen tryckte den dåvarande regeringspartnern Miljöpartiet på för att ge alla samebyar samma rättigheter som Girjas. Socialdemokraterna spjärnade emot och ville först utreda frågan. Resultet blev Renmarkskommittén, som tillsattes 2021. Utredningsdirektivet hade titeln <i>Det samiska folkets rätt till jakt och fiske</i>. I utredningsdirektivet slogs det fast att slutsatserna i Girjasdomen skulle styra kommitténs arbete.</p>
<p>Kommitténs arbete präglades från början av interna meningsskiljaktigheter framför allt mellan utredningens sekretariat och de av riksdagen tillsatta ledamöterna. Kritikerna avfärdade utredningen som ett politiskt beställningsjobb och oron var stor bland organisationer som Svenska Jägareförbundet och Sportfiskarna.</p>
<h2><b>Tingsrätten ska avgöra vilken forskare som har rätt</b></h2>
<p>Eric M Runesson kom snabbt fram till att samebyarna hade lagen på sin sida. Den historiska utredningen av markanvändningen i renbetesområdet, framtagen på uppdrag av kommitténs sekretariat, visade tydligt att ”Girjasrätten” gällde för alla Sveriges samebyar, menade han.</p>
<p>Den bevisning som Renmarkskommitténs ordförande och sekretariat baserade sin ståndpunkt på var i princip densamma som användes i Girjasmålet – och i Talmas stämningsansökan.</p>
<p>Denna forskning hävdar att samebyarna upparbetat det som kallas urminnes hävd, ett juridiskt begrepp som innebär att den som regelmässigt verkat på ett visst område utan konkurrens från andra därmed kan ha upparbetat en rättighet till verksamheten. Det kan gälla jakt och fiske – men även rätten att driva ett vattenkraftverk.<sup>1</sup></p>
<p>I början av februari avvisade Justitiekanslern (JK) Talmas krav med hänvisning till att det historiskt förekommit konkurrerande markanvändning i det aktuella området och att samebyn alltså inte kan få ensamrätt enligt urminnes hävd.</p>
<p>I en tvåhundrasidig historisk utredning som beställdes av JK efter Talmas stämningsansökan har fyra forskare vid Luleå tekniska universitet gjort en fristående granskning av vilka som levde och verkade i området under den aktuella tidsperioden. Historikern <strong>Judit Malmgren</strong>, rapportens huvudförfattare, säger att det historiskt funnits en blandad etnisk-folklig bosättning i Torne lappmark. En stor del av denna befolkning – tornedalingar, lantalaiset och kväner – är erkända nationella minoriteter och uppskattas tillsammans vara mellan 75 000 och 150 000, alltså betydligt fler än samerna.</p>
<p>– Vi tittade på ett större område än bara det som Talma hänvisat till i sin stämning. Under den period som det gäller, 1500–1750, fanns heller inte denna sameby utan där fanns två andra så kallade lappbyar med en helt annan utbredning, säger Judit Malmgren. Hon tillägger att det inte bara är den geografiska utbredningen som har förändrats genom århundradena, utan också markanvändningen.</p>
<p>Området som ligger i anslutning till Torne älv gjorde det till en naturlig plats för tornedalsbönder att nyttja för fiskefärder och sedermera att bosätta sig på, jämte de samer som redan bodde där.</p>
<p>– Även de bofasta rörde sig över stora områden, de höll sig alltså inte inom det som är dagens gränser för Talma sameby och använde marker långt ifrån den egna gården för att jaga, fiska och bedriva handel, säger Judit Malmgren.</p>
<div class = "kv-cruta closed grey cr-round "      id    = "cruta-eZmyJHBbIk"></p>
<h2>Läget fem år efter Girjasdomen</h2>
<p>I en artikel i Kvartal (<a href="https://kvartal.se/artiklar/girjasdomen/">27 april 2020</a>) intervjuade naturjournalisten <b>Carl-Axel Fall </b>ordföranden i Girjas sameby,<b> Matti Berg</b>. Han frågade då vilka som skulle få fiska och jaga i byns område efter HD-domen några månader tidigare.</p>
<p>”I första hand tänker vi på renen och naturen, sen samebyns medlemmar. Innan 1993 levde flera i samebyn på jakt och fiske, nu kan de återgå till det. Utrymmet som är kvar ska gå till lokala jägare och fiskare, Kiruna- och Gällivarebor och norrbottningar. Stockholmare och sörlänningar göre sig icke besvär”, svarade ordföranden.</p>
<p>Fyra år senare har Girjas kortat säsongen för småviltsjakten och fiskeintresserade bosatta utanför Norrbottens län får inte längre lösa fiskekort hos Länsstyrelsen.</p>
<p>Kvar för den som vill uppleva ett av Sveriges absolut bästa fiskevatten för lax, öring och harr är att vända sig till Tjuonajokk fiskecamp, där ett fiskepaket börjar på drygt 40 000 kronor. Då ingår dock inkvartering och helikoptertransport.</p>
<p>Men att lösa ett fiskekort för några hundralappar är alltså inte längre möjligt för ”sörlänningarna”.</p>
<p>Vintern 2024 stängde Girjas vinterfisket och vinterjakten för alla.</p>
<p></div>
<p>Vilka forskare som har mest ”rätt” blir nu upp till Gällivare tingsrätt att avgöra. Lyckas samebyarna övertyga domstolen om att de var ensamma om att jaga och fiska på sina marker för några hundra år sedan så vinner de. Om JK lyckas övertyga dem om att det fanns konkurrenter om jakten och fisket under denna historiska period, då vinner staten.</p>
<p>Framtiden för jakten och fisket i stora delar av de svenska fjällen hänger alltså på vem som lyckas lägga fram den mest övertygande historieskrivningen i domstol.</p>
<p>– Det här är enligt min mening en fråga där det hade varit bra om juridiken hade hållits utanför och man hade kunnat lösa det politiskt. Vi jurister är liksom illa skickade att avgöra den här sortens frågor, säger Jakob Heidbrink.</p>
<p>Och att kartlägga exakt vad som hände i fjällen för mer än 300 år sedan låter sig inte göras så enkelt, skriver JK i sin inlaga till Tingsrätten. Källmaterialet är nämligen begränsat.</p>
<p><em>”Det saknas formell historisk forskning om området och dess befolkning före 1800-talet… Avsaknaden av tidigare forskning utifrån invånarnas egna perspektiv kan förklaras av att de folkgrupper som levde i området i det närmaste saknar egenproducerade berättelser och skriftliga källor före denna tid.”</em></p>
<p>Dessutom skriver JK i sitt svar på stämningarna att historieforskningen de senaste decennierna kommit att influeras av moderna tiders identitetspolitik:</p>
<p><em>”Under de senaste 20–30 åren har postkolonial teori och urfolksmetodologier blivit tongivande inom forskningen som rör lappmarkernas befolkning. Forskningen har därmed bedrivits utifrån en uttalad politisk agenda vilket riskerar att färga det resultat som viss forskning har lett fram till.”</em></p>
<p>En liknande analys fanns med i LTU:s Talmarapport:</p>
<p><em>”Högsta domstolen 2020 &#8230; bygger delvis på tidigare tolkningar av historiska källor som utgår från föreställningar om bland annat etnicitet, bosättning och markanvändning, utan stark empirisk grund, och som stundtals har tendentiösa drag.”</em></p>
<h2>”Rätten måste gälla alla samer”</h2>
<p>Men oavsett vem som till slut får rätt juridiskt så har frågan skapat splittring. Vissa remissinstanser ifrågasatte om kommitténs förslag var förenligt med grundlagen och Kiruna kommun varnade för att förslaget riskerar att öka konflikterna mellan olika befolkningsgrupper. Även samiska organisationer som Jakt- och fiskesamerna och tornedalingarnas organisationer var kritiska.</p>
<p>– Ensamrätten till jakt och fiske måste tillfalla alla samer, inte bara dem som är medlemmar i dagens samebyar, säger <b>Håkan Jonsson</b>, ordförande för Jakt- och fiskesamerna.</p>
<p>Jonsson hoppas på att regeringen snabbt tillsätter en ny utredning för att hitta en lösning efter att den nuvarande misslyckats att ena. Han menar också att den föråldrade renskötsellagen behöver reformeras. Den reglerar vilka rättigheter samerna har – och omfattar idag endast medlemmar i samebyarna.</p>
<p>– Vi måste även säkerställa att alla som bor här uppe ska kunna jaga och fiska till ett billigt pris, oavsett om det gäller samer eller övrig befolkning, säger Håkan Jonsson.</p>
<p>Eric M Runesson avfärdar dock att det skulle handla om orättvisa. Samebyarna, menar han, är arvtagare till äldre tiders lappbyar och därmed rättmätiga ägare av jakten och fisket på den mark som de brukat i hundratals år. De skulle alltså bara få tillbaka vad staten tagit ifrån dem (<a href="https://kvartal.se/artiklar/forenklingar-om-samernas-rattigheter/">Kvartal 2 oktober 2024</a>).</p>
<p>– Den rätten har gått i arv precis som vilken annan civil rättighet som helst och kan jämföras med en äganderätt, säger han.</p>
<p>Att det råder missnöje bland övriga samer med att samebyarna skulle få ensamrätt till jakt och fiske är något som Eric M Runesson beklagar.</p>
<p>– Det har tyvärr uppstått en splittring mellan renskötande och icke-renskötande samer som eldas på av missförståndet om att det är någon slags allmän rättighet för samer att ha markrättigheter. Ursprunget till det tror jag kan vara en oklar formulering i Skattefjällsdomen [från 1981], där Högsta domstolen skrev att renskötselrätten bygger på urminnes hävd och tillkommer det samiska folket.</p>
<p>Denna skrivning har kommit att bokstavstolkas av vissa, menar han.</p>
<h2>Försämrat samarbetsklimat efter domen</h2>
<p>I en rapport från den svenska besöksnäringens branschorganisation Visita beskriver företagarna i norr hur samarbetsklimatet försämrats efter Girjasdomen:</p>
<p><em>”Från samförstånd och en målsättning om att hitta pragmatiska lösningar har tonen hårdnat efter Girjasdomen. Varannan företagare i det berörda området är enligt den enkät som Visita gjort oroliga för utvecklingen. På kort och lång sikt är detta ett hot mot turismen och den ekonomiska utvecklingen i Norrlands inland.”</em></p>
<p>Skogsindustrin i norr är redan idag involverad i ett antal rättsprocesser mot samebyar. Statliga Sveaskog har därför dragit ner produktionen med 40 procent i Norrbotten, enligt <strong>Isak From</strong>, socialdemokraternas ledamot i den nedlagda Renmarkskommittén.</p>
<p>Historieprofessorn <strong>Dag Avango</strong> vid Luleå tekniska universitet och en av författarna till LTU-rapporten, menar att de juridiska processerna riskerar att leda till ytterligare polarisering.</p>
<p>– När vi träffat människor i samband med vår forskning har vi märkt att det finns en stor upprördhet bland dem som hamnat utanför den grupp av samer som gör anspråk på rätten att förvalta jakt och fiske. De menar att de också levt här jättelänge och undrar varför de inte längre ska kunna köpa jakttillstånd och fiskekort hos Länsstyrelsen.</p>
<p>– Av den anledningen är det också viktigt att beslut fattas på ett gediget kunskapsunderlag, där grupper inte osynliggörs, säger Dag Avango.</p>
<div class="notes-wrapper"><a class="shadow-button noselect show-notes"  data-articleid="162426">  <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>https://svenskvattenkraft.se/den-som-vantar-pa-nagot-gott-vantar-aldrig-for-lange/</li>
</ol>
</div>
</div>
<div class="author-byline">Göran Fröjdh är reporter på Kvartal.
</div>
</div>
