Resa: Sveriges nordligaste snabbladdare


<p class="has-medium-font-size"><strong>Den står i Karesuando, Sveriges nordligaste snabbladdare. Där måste man ju ladda! Vi tar Inlandsvägen upp, adderar ständigt nya resmål, för att sedan köra kustvägen söderut. Allt med tältet på dragkroken.</strong><div id="elbilen_panorama-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_panorama-1"});});</script><div id="elbilen_mobil-1"></div><script>lwhb.cmd.push(function() {lwhb.loadAd({tagId: "elbilen_mobil-1"});});</script></p>



<p>Idén föddes en vinterkväll framför brasan. ”Hmm, var kan Sveriges nordligaste snabbladdare tänkas stå?” blev en sökning på Chargefinder – och sedan blev det målet för följande sensommars reportageresa. Uppladdningen började tämligen omgående och de läsare som besökte Elbilens monter på eCarExpo på Stockholmsmässan i maj fick se de första bitarna falla på plats. Där stod nämligen min långtidstestvagn, Zeekr X, försedd med dragkrokstält från Thule.</p>



<p>Friluftsmärket Outnorth sponsrade montern och resan med bord och stolar från varumärket Artic Tern. Jag vill också rikta ett stort tack till danska Outwell som sponsrade resan med två sovsäckar, samt Sverigeklassikern Trangia som försåg oss med ett stormkök. Laddningen i landets mellersta delar skedde i samarbete med Ionity, som nu varit vår partner på flera långresor. Laddaren i Karesuando tillhör emellertid Kiruna-baserade kWatt – som också tyckte vår reportageidé var rolig och därför blev vår laddpartner i Norrbotten. Tack allesammans!</p>



<p>Sista bestyret blev att övertala frun om en tältsemester. På 360 mil. Med elbil. Till Norrbotten. Det tog faktiskt inte många sekunder. Hurra, nu kör vi!</p>



<p><em><strong>Dag 1, 12 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Norrtälje–Nusnäs. </em><br><em><strong>Längd:</strong>&nbsp;335 km.</em><br><em><strong>Laddning:</strong> 42,42 kWh, Ionity Mora.</em></p>



<p>Bilen är fullastad och fulladdad. Beräknad räckvidd är 461 km, alltså något mer än WLTP-räckvidden på 446 km. Det är 325 km till Ionity Mora, men vi har några stopp på vägen också. Och ett tält på dragkroken. Det ska bli intressant att se hur energieffektivt det är.</p>



<p>I början av året gjorde jag ett motorvägstest, exakt samma sträcka kördes med och utan takbox. Då fick jag fram att ökningen var endast 15 procent, lägre än vad jag hade trott. Ett tält på dragkroken, som alltså inte fångar någon fartvind, borde således inte påverka förbrukningen i någon större utsträckning.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01-1.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01-1-1030x579.jpg" alt="" class="wp-image-37771"/></a><figcaption class="wp-element-caption">Bullfest, bullfest hela da’n!</figcaption></figure></div>


<p>Första stoppet blir i Österfärnebo. Här finns nämligen ett mysigt bageri, alltid fullt av pensionärer och motorcyklister. Vi kör alltså vackra väg 272, som kort senare passerar samhället Gammelstilla som är så sött att plomberna trillar ut. Här finns både loppis och whiskytillverkning.</p>



<p>På Långbryggan i Rättvik stannar vi för en bensträckare och inmundigande av godsakerna från bageriet. Siljan är som vanligt fängslande vacker. Till kvällen når vi Mora där vi förundras över att allt kring Vasaloppet redan är på plats, i mitten av augusti. I kommentarfältet till vårt publicerade videoklipp får vi informationen om att det ska vara Cykelvasan till helgen. Den har tydligen körts sedan 2009.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01-2.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01-2-1030x579.jpg" alt="" class="wp-image-37772"/></a><figcaption class="wp-element-caption">Redan första dagen gick vi i mål.</figcaption></figure></div>


<p>När vi laddar på Ionity visar snittförbrukningen 1,56 kWh/mil över 33 mil. Lugn körning absolut, men framför allt verkar tältet påverka förbrukningen ytterst marginellt. Normalt ligger förbrukningen på höga 1,4 på sommaren och nu är bilen dessutom full med last. I min minutiösa reseplanering står det att vi ska övernatta på Vildmarksfisket i Mora. En jättefin plats, men öde eftersom turistsäsongen redan verkar vara över.<br><br>Och vi vill se Siljan. I Nusnäs finns, förutom dalahästar, en mängd ställplatser. På ställplatser står det alltså husbilar och husvagnar i täta rader. Man betalar en mindre summa per natt och får tillgång till olika faciliteter. Vi ser husbilsfolkets undrande blickar när vi rullar in. ”Var ska de sova?” och ”Varför har de en gengastank bak på bilen?”</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01-03.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01-03-1030x579.jpg" alt="" class="wp-image-37773"/></a><figcaption class="wp-element-caption">Vackert vid rofyllda Siljan – fram till det blev kaos följande morgon.</figcaption></figure></div>


<p>Vi väljer en plats som bara har två andra gäster. En grusparkering eller vändplats är bästa beskrivningen. Monteringen av tältet har vi övat på hemma och börjar nu få fason på. Bord och stolar ställs fram och det lagas gulasch. Någon öl slinker ner för mig också. Sedan kommer regnet …<br><br>På området finns en toalett med kodlås på dörren. Varje knapptryckning följs av pip som ekar över området, känns det som i tystnaden. Dörren gnisslar något vansinnigt. Pinsamt, man vill ju vara en god granne när omgivningen sover.</p>



<p><em><strong>Dag 2, 13 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Nusnäs–Hoververg. </em><br><em><strong>Längd:</strong>&nbsp;260 km.</em><br><em><strong>Laddning:</strong> 31,71 kWh, Ionity Sveg.</em></p>



<p>Klockan 05.30 väcks vi av ett enormt oväsen. En grävmaskin och ett gäng långtradare har intagit parkeringen för att hämta en gigantisk grushög. Vi förstår varför det var glest på denna ställplats. En man på åkgräsklippare ansluter till kakofonin. Under ett gott skratt med våra grannar packar vi ihop all utrustning och tar sikte på Inlandsvägen. Jag har förklarat för Tanja att nu behöver vi inte byta väg fler gånger, E45/Inlandsvägen går hela vägen till Karesuando.</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-05.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-05-1030x579.jpg" alt="" class="wp-image-37778"/></a></figure>



<p>Den vackra vägen tar en svängom åt väster för att passera Sveg. Där ska vi ladda. Det fungerar inte. Tio försök plus support. Sveg är något av en laddmetropol, så trots samarbetet med Ionity flyttar jag bilen till OKQ8. Det fungerar inte heller. Så jag rullar till Tesla. Samma visa där. Medan Tanja bekantar sig med den stora träbjörnen och köper lunch försöker jag hitta en påse att andas i. Blodtrycket är högt.<br>Till slut startar jag om bilen, en finnes som involverar bromspedalen och några rattknappar. Något jag aldrig tidigare behövt utföra för att kunna ladda. Sedan rullar jag tillbaka till Ionity och laddningen startar direkt. Total tidsåtgång: 3,5 timmar.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-02.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-02-1030x579.jpg" alt="" class="wp-image-37775"/></a><figcaption class="wp-element-caption">En halvdag i Sveg hade vi inte kalkylerat med. Det blev resans första och enda laddstrul – och inte på grund av laddaren. Det var också första och enda gången på över ett år som bilen vägrade ta emot laddning.</figcaption></figure></div>


<p>Detta var också vårt enda strul på hela resan. För det kan sägas direkt: infrastrukturen för snabbladdning är väl utbyggd även norr om huvudstaden. Vi hittar till och med laddplatser långt från civilisationen, i skogen strax efter norr om Västbacka, där E45 skiljer sig från väg 310.<br>Planen att bara köra E45 håller till Svenstavik.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-03.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-03-1030x579.jpg" alt="" class="wp-image-37776"/></a><figcaption class="wp-element-caption">Hoverbergsgrottan är ett spännande besök som vi varmt kan rekommendera&#8230;</figcaption></figure></div>


<p>Där tar vi istället väster om Storsjön och besöker den fantastiska Hoverbergsgrottan och utsiktsplatsen ovan på samma berg. På väg ner från toppen hittar vi en lugn badvik där vi slår läger, det har trots allt blivit en lång och något påfrestande dag.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-04.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando02-04-1030x579.jpg" alt="" class="wp-image-37777"/></a><figcaption class="wp-element-caption">… i kombination med att även besöka utsiktsplatsen på toppen av berget.</figcaption></figure></div>


<p><em><strong>Dag 3, 14 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Hoververg–Vilhelmina. </em><br><em><strong>Längd:</strong>&nbsp;260 km.</em><br><em><strong>Laddning:</strong> 46,06 kWh, Ionity Ytterån, 10,94 kWh, Ionity Hoting.</em></p>



<p>En bättre morgon, nu får vi vakna till sången av tranor, som är mitt favoritdjur. Det visar sig också, att vi efter att snurrat runt hela berget, har slagit läger bara några hundra meter från entrén till Hoverbergsgrottan. Roligt och förvirrande!</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-01-1030x579.jpg" alt="" class="wp-image-37779"/></a><figcaption class="wp-element-caption">När vi vaknar till transång märker vi att vi slagit läger helt nära Hoverbergsgrottan – trots den långa omvägen efter besöket.</figcaption></figure></div>


<p>Anledningen till vår ändrade rutt är två. För det första tar denna väg oss förbi Trångsviken där Trangia har sin verksamhet. Det klassiska stormköksmärket fick en renässans i samband med pandemin, när alla skulle ut i skog och mark; vilket innebär att det blåser medvind i samband med 100-årsfirandet nu i år.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-02.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-02-1030x579.jpg" alt="" class="wp-image-37780"/></a><figcaption class="wp-element-caption">100-årsjubilerande Trangia har en ny fabriksbutik med tillhörande museum.</figcaption></figure></div>


<p>Vi får en guidad tur med självaste vd, Magnus Rydell. En i princip helsvensk produktionskedja, med finurliga synergier kring underleverantörer (gasolbrännarpåsen är en biprodukt från Whoolpowers produktion av underställ i ull) imponerar stort. Passa på att besöka deras nya fabriksbutik och museum när du passerar.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-03.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-03-1030x579.jpg" alt="" class="wp-image-37781"/></a><figcaption class="wp-element-caption">Vi bestämde träff med vd och elbilsentusiast Magnus Rydell. Trangias produktion är en nästan helsvensk historia.</figcaption></figure></div>


<p>För det andra medför den här rutten att vi passerar Ionity-laddaren i Ytterån. Nästa laddare för Ionity dröjer sedan till Hoting. Där blir det en kyss (kort laddning), men framför allt ett stopp på den vackra rastplatsen vid korsningen mot väg 346. Jag tar fram min reseplanering igen och konstaterar att vi natten innan skulle ha sovit i Brunflo. Så blev det ju inte alls. </p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-06.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando03-06-1030x579.jpg" alt="" class="wp-image-37782"/></a><figcaption class="wp-element-caption">Det roliga med en kompakt bil och ett litet tält är att man kan slå läger på oväntade platser. Tack till Outnorth för campingmöblerna och till Trangia för köket.</figcaption></figure></div>


<p>I natt ska vi sova någonstans i Storuman. Strax söder om Vilhelmina, alltså fem mil söder om Storuman, svänger vi av E45 och hittar ett vattenkraftverk. Det är vindstilla och inte ett moln på himlen, en helt magisk sommarkväll. Då detta inte är en ställplats väljer jag att inte gå in närmare på vad platsen heter (med det finns inte många kraftverk söder o Vilhelmina …) men vi bestämmer oss för att slå läger – och bara njuta av stillheten</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karsuando03-05.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karsuando03-05-1030x579.jpg" alt="" class="wp-image-37783"/></a><figcaption class="wp-element-caption">I Hoting finns en Ionity-station samt en vacker rastplats. Och Ivars Bilmuseum – vilket vi insåg långt senare.</figcaption></figure></div>


<p><em><strong>Dag 4, 15 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Vilhelmina–Moskosel. </em><br><em><strong>Längd:</strong>&nbsp;280 km.</em><br><em><strong>Laddning:</strong> 51,73 kWh, Ionity Storuman</em></p>



<p>Sol och blå himmel har bytts mot duggregn och dimma. Typiskt när man ska ta sig upp i Storumans utsiktstorn. Några fjäll får vi ändå se, innan nästa stopp som är besökscentret i Sorsele med bra museum om Inlandsbanan.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-01-1030x579.jpg" alt="" class="wp-image-37784"/></a><figcaption class="wp-element-caption">Mulet i Storuman. Synd.</figcaption></figure></div>


<p>Regnet kommer och går när vi glider genom dalar och skog, in i Norrbottens län. Strax efter Arvidsjaur tar vi höger på väg BD 651 för att besöka Grodkällan. Precis när vi anländer tittar solen fram och det blir en härlig spångpromenad över en myr. Plötsligt uppenbarar sig källan, som består av klart turkost vatten som pulserar upp ur den vitaste av sand långt nere på botten. Wow, missa inte detta!</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-02.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-02-1030x579.jpg" alt="" class="wp-image-37785"/></a><figcaption class="wp-element-caption">Ett besök vid Grodkällan är ett måste – även om det regnar och bilen blir fasligt smutsig.</figcaption></figure></div>


<p>Åter på parkeringen förbannar jag grusvägen vi kört sedan E45. Så här smutsig har bilen aldrig varit – eftersom jag handtvättar den två gånger i veckan. En halvtimme senare kommer vi till Moskosel, och med en sådant namn på samhället bör det ju finnas möjlighet till laddning. Här står vår resas första kWatt-laddare så det är dags att byta operatör. Vi har fått en tagg skickad med posten, kWatt har ännu ingen app, men betalkortslösning på de flesta stationer.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-03.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-03-1030x579.jpg" alt="" class="wp-image-37786"/></a><figcaption class="wp-element-caption">Det finns el från kWatt i Moskosel …</figcaption></figure></div>


<p>Det finns gott om mäktiga forsar att besöka i norra Sverige. Vi har bestämt oss för Trollforsen cirka tre mil utanför Moskosel. På grusväg. Eller lerväg dagen till ära. Mitt blodtryck går upp igen. När vi kommer fram är det ösregn och storm, men vi tar ändå en promenad till hängbron. Vi tar en annan grusväg tillbaka mot E45; och kommer ut vid Fricamping Pite Älv som ligger tio mil söder om Jokkmokk dit vi planerat att nå denna dag. Lika bra att slänga den där resplanen. Älven brusar vilt men vi slår läger ändå.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-04.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-04-1030x579.jpg" alt="" class="wp-image-37787"/></a><figcaption class="wp-element-caption">Trollforsen, lika blöt i vattnet som i luften.</figcaption></figure></div>


<p>På natten väcks vi av skratt och mansröster. Först nu slår det oss att vi inte någon natt stått på inhägnad camping, som medför ökad trygghet. På morgonen visar det sig att rösterna tillhör tre försynta Stockholmsgrabbar, på väg mot Kebnekaise. Således lugnt, men en tankeställare. I tält är man mer oskyddad än i husbil/husvagn. Något att ha i åtanke.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-05.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando04-05-1030x579.jpg" alt="" class="wp-image-37788"/></a><figcaption class="wp-element-caption">Fricamping vid Pite älv. Glöm inte hörselskydd om du är känslig för ljudet av forsande vatten.</figcaption></figure></div>


<p><em><strong>Dag 5, 16 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Moskosel–Jokkmokk. </em><br><em><strong>Längd:</strong>&nbsp;100 km.</em><br><em><strong>Laddning:</strong> 49,51 kWh, kWatt Moskosel.</em></p>



<p>Den brusande älven. Regn. Blåst. Plus de andra campinggästerna. Det blev en natt med dålig sömn; vi är frusna och allting är fuktigt. Vi lämnar Moskosel efter en laddsession och stannar vid Polcirkeln för pliktskyldiga bilder. På första bästa mack i Jokkmokk köper jag nya batteriet till bilnyckeln, det är dumt att stå mitt i vildmarken med en bil som inte kan prata med nyckeln. Telefonen fungerar visserligen också som nyckel, men ändå.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando05-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando05-01-1030x579.jpg" alt="" class="wp-image-37789"/></a><figcaption class="wp-element-caption">Polcirkeln. Klistermärken.</figcaption></figure></div>


<p>Det var ”länge sedan” vi intog en lagad måltid till bords och vi vill verkligen ha renskav och souvas. På den samiska kulturens museum Ájtte, som är värt ett besök, finns en bra restaurang. Men priserna! Vi tittar på en ”sylta” längre bort på gatan. Ännu dyrare! Saint-Tropez, Monaco och Båstad är rena rama rean jämfört med Jokkmokk.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando05-02.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando05-02-1030x579.jpg" alt="" class="wp-image-37790"/></a><figcaption class="wp-element-caption">Fegt! Vi tog en natt i en campingstuga för att återställa kroppstemperaturen.</figcaption></figure></div>


<p>Vi njuter varje tugga och går sedan länge genom utställningen. Får upp kroppstemperaturen igen.<br>Vi bestämmer oss för att hyra en stuga på Artic Camping. Vi fyller torkskåpet i stugan och stegar bort till bastun. Kvällen avslutas med en rekorddyr renskavspizza.</p>



<p><em><strong>Dag 6, 17 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Jokkmokk–Jukkasjärvi. </em><br><em><strong>Längd:</strong>&nbsp;470 km.</em><br><em><strong>Laddning:</strong> 48,91 kWh, kWatt Porjus, 52,91 kWh, kWatt Karesuando.</em></p>



<p>Varma och utvilade. Efter Jokkmokk gör vägen några böjar ned mot Luleälven. Överfarten vid Aspudden är mäktig, vilka krafter! Vi återser ett italienskt par på motorcykel. Jag försöker berätta att vi såg dem för två dagar sedan. De förstår inte ett ord engelska. Jag använder Google Translate till italienska. De blir ännu mer förvirrade. Spännande att lyckas komma hela vägen hit från Italien utan att kunna kommunicera …</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karsuando06-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karsuando06-01-1030x579.jpg" alt="" class="wp-image-37791"/></a><figcaption class="wp-element-caption">Man kan filosofera över om energin från älvens kraftverk någon gång har varit en del av den energimix vi laddat bilen med. Eller så kan man helt enkelt titta på utsikten.</figcaption></figure></div>


<p>Vattenkraftverket i Porjus bjuder på mäktigt industriarkitektur. I samhället finns även en kWatt-laddare där vi tankar upp och intar frukost. I Gällivare kör vi fel; missar den diskreta uppfarten till toppen av Dundret. Turen tillbaka är värd besväret, trots dåliga vägar och vägarbeten, är utsikten enorm. Här ser vi också de första spåren av gruvbrytning, något som blir ett tema ju närmare Kiruna vi kommer.<br>Högersväng i Svappavaara. Vänstersväng i Vittangi. Bebyggelsen glesnar. I Övre Soppero står en kWatt-laddare på en privat tomt (där man får köra in) men jag är ivrig till målet och tänker att vi har energi så att det räcker.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-03.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-03-1030x579.jpg" alt="" class="wp-image-37792"/></a><figcaption class="wp-element-caption">Missa inte infarten till utsiktsplatsen på toppen av Dundret. Här kan man även stanna för en vandring.</figcaption></figure></div>


<p>Kuperad terräng, vind samt regn och en något högre snittfart än normalt drar upp förbrukningen till 1,84 kWh/mil. Med 51 km/14 % kvar i batteriet rullar vi in på Bymacken i Karesuando. Och där står den – Sveriges nordligaste snabbladdare!</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-04.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-04-1030x579.jpg" alt="" class="wp-image-37793"/></a><figcaption class="wp-element-caption">Framme! Vi har nått målet – Sveriges nordligaste snabbladdare! Direkt tar vi beslut om ett nytt resmål.</figcaption></figure></div>


<p>Vi firar med våra långfärdsankor (förklaras i filmerna …) och besöker butiken som skyltar med ”Vi har allt … nästan”. Det stämmer och jag slår till på en Karesuando-dekal till resväskan. Eftersom min fru är finska kan vi inte motstå ett besök i finska Karesuando. Det blir lyxig lunch med äpplemunk (Possumunkki) till efterrätt på Rajacafé. Rustikt och genuint.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-05.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-05-1030x579.jpg" alt="" class="wp-image-37794"/></a><figcaption class="wp-element-caption">I finska Karesuvanto äter man rustikt och gott på Rajacafé. Raja betyder gräns.</figcaption></figure></div>


<p>Dags att vända söderut igen. Men först ett kulturstopp med Laestadius Pörte, tillhörande den kärve prästen Lars Levi Laestadius (1800–1861) , samt en bild vid vägskylten som förkunnar ”Sveriges nordligaste allmänna väg”. Varför hade inte laddaren någon skylt? Miljöerna är vackra men det är betydligt mer skog än vad jag hade väntat mig. Bara ibland är utsikten milsvid.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-07.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando06-07-1030x579.jpg" alt="" class="wp-image-37795"/></a><figcaption class="wp-element-caption">Vi förväntar oss att snabbladdaren snart får en liknande vägskylt.</figcaption></figure></div>


<p>U-sväng vid Svappavaara. I Jukkasjärvi börjar jakten på en bra ställplats. Turistsäsongen är tydligen inte alls över. Framåt 20-tiden hittar vi paradiset. En naturhamn för små roddbåtar i sjön Sautusjärvi. Utsikten är bedårande. Vilken dag!</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando01-1030x579.jpg" alt="" class="wp-image-37769"/></a><figcaption class="wp-element-caption">Jackpot när det gäller lägerplatser. Här i Jukkasjärvi stod vi två nätter i rad och njöt varje sekund.</figcaption></figure></div>


<p><em><strong>Dag 7, 18 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Jukkasjärvi–Jukkasjärvi. </em><br><em><strong>Längd:</strong>&nbsp;300 km.</em><br><em><strong>Laddning:</strong> 52,93 kWh, kWatt Kiruna, 23,18 kWh, kWatt Riksgränsen</em></p>



<p>Det är mycket nya hus i Jukkasjärvi. Och den nyasfalterade vägen verkar fortsätta ut i ödebygden. Det visar sig att den går till rymdbasen Esrange – och den enorma vägstandarden är ett tydligen tecken på att vi har gått med i NATO. Esrange har ett obemannat museum. Vi tackar för gratis morgonkaffe!</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando07-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando07-01-1030x579.jpg" alt="" class="wp-image-37797"/></a><figcaption class="wp-element-caption">Esranges lilla rymdraketsmuseum är intressant – och det bjuds på kaffe.</figcaption></figure></div>


<p>Vi har under hela resan haft sms-kontakt med Anders Svonni på kWatt. En trevlig grabb! ”Visst, Karesuando är nog längre norrut än Riksgränsen, men ska ni inte också besöka Sveriges vackrast placerade snabbladdare?”</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando07-05.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando07-05-1030x579.jpg" alt="" class="wp-image-37798"/></a><figcaption class="wp-element-caption">Vi har nått mål två: Sveriges vackrast placerade snabbladdare, i Riksgränsen. Motbevisa oss gärna!</figcaption></figure></div>


<p>Vi antar inviten och gasar upp till Kiruna för ett laddstopp. Vid stolpen träffar vi Julia Laestadius, som har följt vår resa på Instagram – och till råga på allt är den personen som upplåtit tomtmark för en kWatt-laddare i Övre Soppero. Världen är liten. Ni vet det där mötena med främlingar där det känns som att man borde varit bekanta hela livet? Detta är ett sådan möte, Julia och min Tanja är oskiljaktiga.<br>Solen tittar fram, jag propsar på Riksgränsen och på väg ut ur stan hinner vi titta på träkyrkan, redo för morgondagens flytt.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando07-04.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando07-04-1030x579.jpg" alt="" class="wp-image-37799"/></a><figcaption class="wp-element-caption">Kyrkflytt, ett projekt utöver det vanliga</figcaption></figure></div>


<p>Vägen till Riksgränsen är så som jag tänkt mig Norrbotten. Höga berg, några snötäcka fjäll och milsvid utsikt. Regnet kommer och går, men … äh, det börjar bli tjatigt: det är vackert här, speciellt med alla regnbågar. Efter att ha använt vad som beskrivits som Sveriges vackrast placerade snabbladdare vänder vi tillbaka mot Kiruna. Samma väg ser annorlunda ut nu, från det här hållet är bergen nämligen grönare eftersom du är vända mot söder/väst.<br><br>Vi åker tillbaka till vårt paradis utanför Jukkasjärvi. Nu står Bosse här och tittar till sin båt. Vi får absolut låna platsen. Det blir ett långt samtal om framför allt det häftiga i att få bevittna raketuppskjutningarna från Esrange. Och fler lär det bli framgent. När vi avslutar kvällen till solnedgången tar jag fram koordinater för Karesuando och Riksgränsen. Karesuando ligger 1&nbsp;450 meter längre norrut längs meridianen …</p>



<p><em><strong>Dag 8, 19 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Jukkasjärvi–Leipojärvi. </em><br><em><strong>Längd:</strong>&nbsp;140 km.</em><br><em><strong>Laddning:</strong> 49,13 kWh, kWatt Kiruna.</em></p>



<p>Kyrkflytten är ett mäktigt skådespel. Som maskinintresserad tror jag mig se ett reportage kring anordningen som kyrkan åker fram med, vagnarna ser ut att vara eldrivna, dock med stöd av dieselgeneratorer. Idén faller platt när jag bli informerad om att det minsann är hydraulmotorer som används. Attans!</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando08-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando08-01-1030x579.jpg" alt="" class="wp-image-37800"/></a><figcaption class="wp-element-caption">Maskinerna som flyttar kyrkan hade tydligen inte elmotorer. Hmm.</figcaption></figure></div>


<p>Anders på kWatt bjuder på grillade burgare vid deras kontor. Vi tackar ja – och lyckas fastna i historiens enda trafikstockning i Kiruna. Pinsamt! Vi hinner också träffa Julia igen, i samband med att hennes samiska kör uppträder i nya kulturhuset. Vackert!</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando08-02.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando08-02-1030x579.jpg" alt="" class="wp-image-37801"/></a><figcaption class="wp-element-caption">Patrik Tuoremaa och Anders Svonni på kWatt – som bara är ett av flera företag de har vid sin bas i Kiruna.</figcaption></figure></div>


<p>Men nu måste vi börja resan hemåt. Vi tar vänster utanför Gällivare och siktar på kustvägen. Inlandsvägen var enormt fin, men ombyte förnöjer. Det är ensligt på vägarna. Klockan närmar sig 20.00 och jakten på ställplats inleds. En tyvärr rejält nedskräpad men i övrigt bedårande plats hittas vid Leipojärvi.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando08-05.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando08-05-1030x579.jpg" alt="" class="wp-image-37802"/></a><figcaption class="wp-element-caption">Börjar du tröttna på bilder av uppställningsplatser med vackra solnedgångar?</figcaption></figure></div>


<p><em><strong>Dag 9, 20 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Leipojärvi–Robertsfors. </em><br><em><strong>Längd:</strong>&nbsp;420 km.</em><br><em><strong>Laddning:</strong> 23,93 kWh, kWatt Hakkas, 48,94 kWh, kWatt Piteå</em></p>



<p>Det kliar i kroppen när jag behöver köra stora vägar som E10 och E4. Det är längs landsvägar man upptäcker Sverige. Sevärdheten Gammelstads kyrkstad prickas av; innan det är dags för lunch på världens enda Paltzeria i Öjebyhus, där en gammal bekant möter upp och kollar så sörlänningarna gör rätt för sig.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-01-1030x579.jpg" alt="" class="wp-image-37803"/></a><figcaption class="wp-element-caption">Gammelstads kyrkstad.</figcaption></figure></div>


<p>Sista kWatt-laddaren längs sträckan står i Piteå, men nya är under uppbyggnad hela vägen till Umeå.<br>Jag har alltid velat se havsbadet. Det är en ganska sorglig historia ”off season”, med bara jag och Tanja på hela stranden, och bara jag i badbyxor. Jag får springa typ 400 meter ut för att kunna dyka ner under ytan. Det är åtta grader i vattnet. En välbehövlig energikick för att motverka paltkoman.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-02.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-02-1030x579.jpg" alt="" class="wp-image-37805"/></a><figcaption class="wp-element-caption">Världens enda paltzeria. Du lämnar inte etablissemanget hungrig. Det finns en mängd olika paltsorter – men även korv- och fiskrätter att välja bland till lunch.</figcaption></figure></div>

<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-03.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-03-1030x579.jpg" alt="" class="wp-image-37804"/></a><figcaption class="wp-element-caption">Northvolt – eller vad det nu kommer att heta framgent.</figcaption></figure></div>


<p>Den energin går dock i botten när vi något senare stannar till för att kolla på Northvolt. Hoppas detta löser sig, till det bästa. Nu har är det bara spökligt värre. Motorvägsmotståndet blir för starkt, i södra Skellefteå svänger vi istället in på väg 364 och åker förbi Burträsk, Västanträsk och Ytteråträsk; fram till Botsmark där det blir vänster mot Robertsfors.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-04.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando09-04-1030x579.jpg" alt="" class="wp-image-37806"/></a><figcaption class="wp-element-caption">Vi tog på oss alla kläder vi hittade när vi kom till naturistbadet. Inte i protest utan för att inte frysa.</figcaption></figure></div>


<p>Tanja har hittat en populär ställplats vid Killingsand. Det visar sig även vara ett naturistbad. Det är emellertid en kall kväll så vi ser inte en enda person i födelsekostym. Vi dukar upp med vårt camping-bord och -stolar på de fina klipporna och blickar ut över Norra Kvarkens gräns till Bottenviken<br>Kvällen blir rejält kall. Trots att vi har sovsäckarna Camper Lux (för övrigt enormt mjuka och sköna, men skrymmande) som ska vara komfortabla till nollgradigt på kvinnoskalan (fråga mig inte om mätmetoderna för sovsäckar!) blir det underställ och toppluva. Tanken på att inför resan köpa någon form av inomhusvärme och koppla via bilens V2L blev det aldrig något av, det var redan fullt i bilen.</p>



<p><em><strong>Dag 10, 21 augusti</strong></em><br><em><strong>Sträcka:</strong>&nbsp;Robertsfors–Norrtälje. </em><br><em><strong>Längd:</strong>&nbsp;680 km.</em><br><em><strong>Laddning:</strong> 60,87 kWh, Ionity Umeå, 62,23 kWh, Ionity Sundsvall, 38,74 kWh, Ionity Uppsala.</em></p>



<p>Jag vaknar själv. Tanja sitter redan i bilen och värmer sig. Jag har glömt berätta att vi är kort på räckvidd. Spännande! Med 20 km/6 % kvar i batteriet smyger vi oss in på Ionity Umeå. Jag dukar upp kaffe och frukost på tältboxen – den är verkligen i perfekt höjd för häng och fika.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando10-01.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando10-01-1030x579.jpg" alt="" class="wp-image-37807"/></a><figcaption class="wp-element-caption">Vi blir igenkända som &#8221;de med ankorna&#8221; vid laddstoppet.</figcaption></figure></div>


<p>”Är det ni med ankorna?!”, frågar hantverkare tillika elbilsentusiast Patrik Ahlstrand. Ja, visst är det vi, bara lite blåfrusna. Återigen ett av dessa härliga möten vid stolpen. Sedan matas det själsdödande motorvägsmil. Ett långt stopp på Ionity i Sundsvall för att ladda fullt (nej, det var ingen kö!) så att vi kan nå Ionity Uppsala. Det gör vi med 51 km/16 % kvar och vi har alltså avverkat 297 km motorvägskörning med ett snitt på 1,91 kWh/mil. Bra siffror för en fullpackad bil med tält på kroken. Det är cirka 15 grader denna dag.</p>


<div class="wp-block-image">
<figure class="aligncenter size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando10-02.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando10-02-1030x579.jpg" alt="" class="wp-image-37808"/></a><figcaption class="wp-element-caption">Tack för den här gången! Hade vi inte varit genomfrusna hade vi absolut stannat och vandrat vid Skulebergets nationalpark – en favorit, knappt fem mil norr om Högakustenbron.</figcaption></figure></div>


<p>Hösten kom alltså snabbt. Tanken med den sena resan var att slippa mygg. Det gjorde vi. Men nätter i ett oisolerat tält blir kalla. Jättekalla. Men framför allt kom vi hem jättelyckliga. Tack för alla möten! Och tack Sverige för att du är så vackert!</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2025/12/Karesuando-rutt.jpg"><img src="https://elbilen.se/wp-content/uploads/2025/12/Karesuando-rutt-1030x579.jpg" alt="" class="wp-image-37809"/></a></figure>
