Elbilssemester 2025 – vi laddar oss genom Tyskland


<p class="has-medium-font-size"><strong>Utmaningen: en bilresa till mitten av Tyskland, i början av tyskarnas augustisemester, med bara Ionity som laddnätverk. Skulle det bli kaos i stil med svenskt sportlov eller en dans på rosor? Det blev dans till analog musik. Häng med!&nbsp;</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>Osande av självförtroende vill jag överbevisa min fru. Tanja, som hon heter, har sedan vintern 2021, när vi skulle köra från Stockholm till Göteborg, tvivlat på kombinationen längre resor och elbil. Då, en kall novemberhelg, gick allt verkligen åt skogen trots en superlyxig Porsche Taycan som färdmedel. Vid samtliga laddare hade vi problem med betalning eller kontakt mellan laddhandske och bil. Laddnätverket då: Ionity …</p>



<p>Fyra år senare fungerar allt mycket bättre, försäkrar jag. Dessutom ska vi ha en helt otrolig långresebil – Lotus Eletre, grundversionen med ”små” 20-tumsfälgar och en WLTP-räckvidd på upp till komfortabla 600 km. Men det bästa av allt, det är (var då, för nu finns Lotus Emeya med 400 kW i laddeffekt) den mest snabbladdande bilen på marknaden med 350 kW i maxkapacitet.&nbsp;</p>



<p>Tanja ser skeptisk ut. För att utmana situationen adderar jag två försvårande omständigheter: vi ska inte äta lunch/middag på restaurang vid laddstoppen (för det ska kommer vi inte hinna) och vi ska inte använda destinationsladdare vid våra övernattningar (för bilen har tillräcklig räckvidd i förhållande till Ionitys täckningsgrad).</p>



<p>Resans mål är kulturstaden Weimar. Här ska nämligen elvamannabandet Meute stanna till på sin Europaturné. Meute är ett tyskt ”techno marching band”, man spelar alltså techno och elektronisk dansmusik, fast med trummor och blåsverk. Energin är magisk! Jag skulle ha sett Meute i Stockholm 2019, men en pandemi kom i vägen. Väntan har alltså varit lång.&nbsp;</p>



<p>Visst ja, det var en sak till som gör reseplaneringen speciell – och kanske den som gjorde allt extra smidigt och minnesvärt. Rutten jag har programmerat i Google Maps är i Danmark och Tyskland lagd med ”Undvik motorväg” aktiverat. För oss så handlar resa om att se saker och samla upplevelser. Svensk motorväg och Autobahn kan vara bland det mest själsdödande som finns.&nbsp;</p>



<p>Som resan nu gick fick vi istället se mängder av fält med milsvid utsikt, prunkande skogar i bergsmiljö och söta byar med sagolika trädgårdar. Vi kunde samtidigt förundras över vissa fasadfärger. Spaning: i varje tysk by finns ett par hus i skrikiga nästan fluorescerande färger, en bilförsäljare (Autohous) och en brandkår (Freiwillige Feuerwehr).</p>



<p>För över 100 år sedan bestämdes att varje by med mer än 300 invånare ska ha ett eget brandförsvar. Det är uppbyggt på en grund av frivillighet och över en miljon tyskar är utbildade brandmän. Rekryteringen börjar redan i förskolan.</p>



<p>Saker som dessa hade vi aldrig lärt oss om vi valt Autobahn. Tyska landsvägar har 100 km/h som skyltad hastighet så det kryps inte fram i typ 60 knyck som i Sverige … Och de gånger vi korsade Autobahn insåg vi vidden av genidraget. Ute på de flerfiliga vägarna var det konstant massiva köer som smög fram. Att inte fler resenärer vek av till landsvägar för att de facto komma fram snabbare, förblev en gåta.</p>



<p>Ionitys laddstationer är dock placerade längs Autobahn, så klart. Det medförde det roliga i att Googel Maps alltid hittade lustiga bakvägar (läs: traktorstigar) de sista kilometrarna inför varje stopp.</p>



<p>Och hur gick själva laddstoppen då? Timslånga köer och ständiga teknikstrul? Tvärtom! Vid mer än en laddpunkt var vi själva när vi kom och själva när vi åkte, kort senare. Och då utfördes laddningarna ändå mitt på dagen. Det visar sig att tyskarna föredrar laddnätverken EnBw och Allego, men även vid dessa fanns alltid flera lediga laddpunkter.&nbsp;</p>



<p>Resan varade total sju dagar. Tråkigast var sträckorna Roslagen–Skåne tur och retur, men på utresan ville vi fort bort och vid returen infann sig en viss hemlängtan. Med ytterligare någon dag tillgänglig hade vi gärna åkt även genom Sverige på landsvägar.</p>



<p>Om man ska ta färja direkt till/från Tyskland eller köra bro/färja (eller omvägen bro/bro) via Danmark är en fråga om smak och tillgänglig tid. Prismässigt blir det nästan oavgjort när allt är inräknat, även om Tysklands-färja initialt kan låta dyrt.&nbsp;</p>



<p>Vi valde hemresa Travemünde – Trelleborg med TT-Lines för att testa hur elbilsladdning under överfärd fungerar. Supersmidigt! Med detta tillägg får man parkering vid en laddstolpe och personal på plats guidar dig rätt samt startar processen med sitt laddkort. Som bonus placerades vi precis vid fartyget sidoport och kunde köra i land först av alla.</p>



<p>Om man maxar körsträckan sista dagen i Tyskland (eller åt andra hållet) kan man alltså komma till färjan med låg laddnivå. Väljer man dessutom kvällsturen anländer man sedan utvilad – och med bilen fulladdad – på andra sidan av vattnet. TT-Lines verkar vara valet för långtradare, trots högsommar och semestertider hade yrkeschaufförerna och vi sällskap av endast 20-talet personbilar, osedvanligt lugnt enligt tillfrågad restaurangpersonal.<br>Riktigt lika imponerande var inte upplevelsen med Scandlines, där vi bokade kombobiljett för Öresundsbron plus deras färja Rødby – Puttgarden. Men mer om det i följande resedagbok.&nbsp;</p>



<p class="has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background has-background has-medium-font-size"><strong>Dag 1 </strong>– 30 juli</p>



<p class="has-very-light-gray-to-cyan-bluish-gray-gradient-background has-background"><strong>Sträcka:</strong> Norrtälje–Köpenhamn.<br><strong>Längd:</strong> 740 km.<br><strong>Laddtid</strong>: 41 min (tre sessioner).</p>



<p class="has-medium-font-size"><strong>På vägen:&nbsp;</strong></p>



<p>Ren transportsträcka. Bilens navigation, som kan sortera på enbart Ionity, föreslår stopp i Norrköping och Ljungby och menar att laddningarna ska vara i 69 minuter.</p>



<p>Jag sträcker ut körningarna till Mantorp och Ljungby Nord istället, samt fegar med en kort stödladdning före bron för att nå danska Vordingborg med marginal. Laddandet gick långt snabbare än vad bilen utlovat, inklusive stödladdningen.</p>



<p>Bilen är norskregistrerad eftersom det är demobil för den gemensamma importören. Jag har varit minutiös i planeringen och lagt in registreringsnumret i Scandlines-bokningen, så att bommen vid Öresundsbron ska gå upp automatiskt.&nbsp;</p>



<p>Vid Öresundsbron visar det sig, efter mycket om och men samt irriterade bilister i kö bakom oss, att bilen redan har passerat bron den 4 juli. Vår biljett köptes den 2 juli och ska enligt Scandlines börja gälla tidigast 23 juli. Vi får köpa ny brobiljett för 800 kr och sedan följer en dryg månad lång tvist där Scandlines vägrar återbetala pengarna, trots att biljetten inte skulle ha varit giltig när den förra personen som lånade bilen passerade bron. Maken till oförstående och otrevlig kundtjänst har vi aldrig upplevt. Som tur är fungerade färjebiljetten nästföljande dag.</p>



<p>I Köpenhamn har vi planerat parkering i ett garage anslutet till Easypark. Bilen har jag registrerat så att bommen ska gå upp …&nbsp; Det gör den inte. Jag trycker på supportknappen och får veta att bilen redan har en pågående parkering. Det stämmer så klart inte men jag får till slut betala med kort och kan väl känna att nu har det strulat klart för den här resan.</p>



<p class="has-medium-font-size"><strong>Boendet:&nbsp;</strong></p>



<p>Missa inte underbara Axel Guldsmeden Hotel, en lugn och vacker oas (deras innergård!) nära centralstationen. Påkostade och prydliga rum, om än åt det trängre hållet. Den bästa hotellfrukost vi upplevt – någonsin! Flera olika garage på rimligt gångavstånd.</p>



<p class="has-medium-font-size"><strong>Måltiden:&nbsp;</strong></p>



<p>Elbilens fotograf Peter Gunnars hittade Warpigs i samband med att vi arbetade med elbilsmässan eCarExpo 2021. Sedan dess har jag ätit där årligen i samband med mässan och lovordat restaurangen till min fru. Hon blev inte besviken. De bästa köttbitarna du kan tänka dig serverade i klassisk rustikt industriell och ändå utsökt BBQ-känsla. Att Warpigs drivs av bryggeriet Mikkeller garanterar ett imponerande utbud av ölsorter, majoriteten bryggda på plats.&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_5.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_5-1030x579.jpg" alt="" class="wp-image-33159"/></a><figcaption class="wp-element-caption">Navigatorn i Eletre kan sortera på endast Ionity. Tack för det!</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_3.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_3-1030x579.jpg" alt="" class="wp-image-33157"/></a><figcaption class="wp-element-caption">Vi fick 60,13 kWh på 17,79 minuter på Ionity Mantorp. Och några färre flugor.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_2.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_2-1030x579.jpg" alt="" class="wp-image-33156"/></a><figcaption class="wp-element-caption">En svensk (Joakim) och en finska (Tanja) i en norskregisterad, engelsk bil, byggd i Kina, på resa genom Danmark och Tyskland. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_4.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_4-1030x579.jpg" alt="" class="wp-image-33158"/></a><figcaption class="wp-element-caption">Warpigs i Köpenhamn – för kött- och ölälskare. </figcaption></figure>



<p class="has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background has-background has-medium-font-size"><strong>Dag 2 </strong>– 31 juli</p>



<p class="has-very-light-gray-to-cyan-bluish-gray-gradient-background has-background"><strong>Sträcka:</strong> Köpenhamn–Hamburg.<br><strong>Längd:</strong> 295 km.<br><strong>Laddtid</strong>: 20 min.</p>



<p class="has-medium-font-size"><strong>På vägen:&nbsp;</strong></p>



<p>På Själland löper landsvägen parallellt med den något större E45. Danska vägar är imponerande spikraka, det kan inte slitas mycket framdäck här eftersom man slipper svänga … Kuperat är det nästan inte heller men utsikten över de låga åsarna är majestätisk.&nbsp;</p>



<p>I Haslev rekommenderas ett stopp för det spektakulära utsiktstornet Camp Adventure. Det 45 meter höga tornet består av en skruvad gång med tolv varv innan du når toppen. Se till att ha gott om tid eftersom cirklandet i tornet föregås av en skogspromenad från parkeringen.&nbsp;</p>



<p>Nära broarna vid Storströmmen ligger Ionity Vordingborg. En knutpunkt för flera laddoperatörer och mackar, med tillhörande snabbmatställen. Vi fäller istället ut våra solstolar och njuter. Knappt har vi hunnit ta bilden av detta innan laddningen är klar!&nbsp;</p>



<p>När vi når tysk mark följer vår enda Autobahnkörning från Puttgarden till Hamburg eftersom vi har förköpt biljetter till Miniatur Wunderland. Den tyska motorvägen är trist och kryper fram, jag börjar tvivla på att vi ska hinna.</p>



<p>Det gör vi och besöket på museet höjer stämningen avsevärt. Detta är världens största modelljärnvägsmiljö, med hela städer (och en flygplats!) återskapade i detalj. Här hittar du allt från Kiruna till Monaco (med pågående F1-tävling). 1 490 kvadratmeter miljöyta, 260 000 figurer, 1 040 tåg, 4 110 byggnader, 130 000 träd och 9 250 bilar. Själv gjorde jag till en sport att hitta elbilar – och lyckades bra.&nbsp;</p>



<p class="has-medium-font-size"><strong>Boendet:</strong></p>



<p>På smidigt gångavstånd till Miniatur Wunderland valde vi The Nikolai Hotel. Väldesignade rum med en mix av klassiskt och modernt. Stor lobby/bar som var förbluffande öde de gånger vi passerade. Vill man ställa bilen i ett garage är det en bit att gå.&nbsp; &nbsp; &nbsp;</p>



<p class="has-medium-font-size"><strong>Måltiden:&nbsp;</strong></p>



<p>I Hansastaden äter man Hansamat. Det serveras mysiga Schoppenhauer, på en lugn bakgata två dåliga stenkast från Miniatur Wunderland. Restaurangen ska ha grundats redan 1633, vilket den rustika inredningen speglar. Som en modern touch blandas det klassiska köket med asiatiskt för den som föredrar sushi och liknande.&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_10.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_10-1030x579.jpg" alt="" class="wp-image-33164"/></a><figcaption class="wp-element-caption">76,03 kWh på 20,18 minuter! På Ionity 
Vordingborg blev tiden i solstol minimal. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_9.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_9-1030x579.jpg" alt="" class="wp-image-33163"/></a><figcaption class="wp-element-caption">Färjebiljetten hos Scandlines fungerade trots i övrigt usel kundservice. Om du har en bred bil, kom ihåg att boka plats bland lastbilarna &#8230; Tanja höll på att bli kvar i bilen. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_8.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_8-1030x1030.jpg" alt="" class="wp-image-33162"/></a><figcaption class="wp-element-caption">Rustik Hansamat i Hansastaden Hamburg. 
Himmelskt! </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_7.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_7-1030x579.jpg" alt="" class="wp-image-33161"/></a><figcaption class="wp-element-caption">Miniatur Wunderland i Hamburg. Se till att avsätta rejält med tid för besöket.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_6.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_6-1030x579.jpg" alt="" class="wp-image-33160"/></a><figcaption class="wp-element-caption">Joakim körde elbils-spotting på Miniatur  Wunderland. Kia EV9, VW ID3 och VW ID Buzz i bild. </figcaption></figure>



<p class="has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background has-background has-medium-font-size"><strong>Dag 3</strong> – 1 augusti</p>



<p class="has-very-light-gray-to-cyan-bluish-gray-gradient-background has-background"><strong>Sträcka:</strong> Hamburg– Blankenburg.<br><strong>Längd:</strong> 270 km.<br><strong>Laddtid</strong>: 23 min.</p>



<p class="has-medium-font-size"><strong>På vägen:&nbsp;</strong></p>



<p>Ska man snabbt ut ur en storstad bör man inte välja ”Undvik motorväg” i Google Maps. Se till att anslut på första bästa motorvägsled och byt till landsväg utanför stadsgränsen. Tips från ett par som kört i cirklar i Hamburgs hamn alldeles för länge …</p>



<p>Sedan ersätts rundfartsleder av spikraka landsvägar över vackra hedar och genom lummiga skogar. Laddningen på den enorma rastplatsen vid Lüneburger Heide är klar innan jag köat färdigt för en svalkande Radler.&nbsp;</p>



<p>Närmare Blankenburg börjar landskapet bli rejält kuperat. Stanna gärna till i Hessen och besök deras slott från medeltiden. Men slottet i Blankenburg är ännu mäktigare och med milsvid utsikt.&nbsp;</p>



<p class="has-medium-font-size"><strong>Boendet:&nbsp;</strong></p>



<p>Villa Viktoria Luise är en imponerande jugendvilla som ligger längst upp på en smal och brant väg. Det charmiga hotellet är inte del av någon större kedja utan familjärt och intimt. Rummen är stora, har rejäl takhöjd och fräscha badrum. Supercharmig frukost där varje enskild komponent serveras vid bordet. En härlig nostalgitripp till hur hotell var förr.</p>



<p class="has-medium-font-size"><strong>Måltiden:</strong>&nbsp;</p>



<p>Rustik middag i form av fjärilskotlett på hotellets uteservering. Tanja beställer en efterrätt med glass, körsbär, sockerkaka och likör som fortfarande listas som ”den bästa efterrätt jag har ätit i hela mitt liv”.&nbsp;</p>





<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_11.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_11-1030x579.jpg" alt="" class="wp-image-33165"/></a><figcaption class="wp-element-caption">Destinationsladdare finns det gott om, och fler byggs. Här i Braunschweig.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_12.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_12-1030x579.jpg" alt="" class="wp-image-33166"/></a><figcaption class="wp-element-caption">Hälsningar från Hessen. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_13.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_13-1030x579.jpg" alt="" class="wp-image-33167"/></a><figcaption class="wp-element-caption">Vandringen till Teufelsmauer (djävulsmuren) började direkt utanför vårt hotell. Missa inte! </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_15.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_15-1030x579.jpg" alt="" class="wp-image-33169"/></a><figcaption class="wp-element-caption">Blankenburg är kuperat. Bra för den som gillar utsikt. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_14.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_14-1030x1030.jpg" alt="" class="wp-image-33168"/></a><figcaption class="wp-element-caption">Direkt upp på 
topplistan av bästa efterrätter  &#8211; någonsin. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_16.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_16-1030x579.jpg" alt="" class="wp-image-33170"/></a><figcaption class="wp-element-caption">Hotellfrukost som beställs och sedan serveras vid bord med vit duk. Som det var för, fast idag på Villa Viktoria Luise.</figcaption></figure>



<p class="has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background has-background has-medium-font-size"><strong>Dag </strong>4 – 2 augusti</p>



<p class="has-very-light-gray-to-cyan-bluish-gray-gradient-background has-background"><strong>Sträcka:</strong> Blankenburg–Weimar.<br><strong>Längd:</strong> 160 km.<br><strong>Laddtid</strong>: 23 min.</p>



<p class="has-medium-font-size"><strong>På vägen:&nbsp;</strong></p>



<p>Det stora naturreservatet Harz är fullt av gruvor. Inled morgonen i Baumannshöhle, en 50-minutersvandring nere i den spektakulära underjorden. Dock med fotoförbud.&nbsp;</p>



<p>Efter svalka på djupet, kör upp till och promenera över världens längsta hängbro, Titan RT, med utsikt över en enorm damm.&nbsp;Därefter går det nedför genom lummiga skogar till Sangerhausen där vi laddar på en öde Ionity. Lyx!&nbsp;</p>



<p>Detta är ännu en gigantisk rastplats med flera laddoperatörer, mackar – och spelhall. Tyskarna älskar tydligen att gå till en spelhall när de rastar och laddar, för detta är ett återkommande tema. Jag blir dock ännu mer imponerad av det utegym som finns på en av gräsytorna. Anläggningen är sponsrad av Mercedes-Benz lastbilsdivision och Truckers Life Foundation. Tradarchaffisarna lyser med sin frånvaro, kanske eftersom gymmet ligger direkt utanför en restaurangs stora utsiktsfönster. Men initiativet är beundransvärt!&nbsp;<br>Har du kvar spring i benen passar du på att svänga in till Hohe Linde, en enorm bergsuppkastning skapad från brytningen av kopparskiffer i området.</p>



<p>Dagen avslutas i kulturstaden Weimar. Hem för Johann Wolfgang von Goethe, vilket medför att mycket kretsar kring den kända författaren. För oss väntar annan kultur – konserten med Meute som jag har väntat på sedan 2019. Det blir en magisk sommarkväll i vackra Weimarhallenpark.&nbsp;</p>



<p class="has-medium-font-size"><strong>Boendet:&nbsp;</strong></p>



<p>Hotel Schillerhof ligger centralt men är ändå tyst och lugnt. En opersonlig digital incheckning på gigantisk pekskärm står i bjärt kontrast till föregående natts personliga hotell. Tokdyr frukost, men gågatan utanför kryllar av uteserveringar eller snabbköp för den som vill komponera egen frukost och inmundiga i valfri park.&nbsp;</p>



<p class="has-medium-font-size"><strong>Måltiden:</strong></p>



<p>Mitt i Weimars äldsta kvarter ligger Benediktiner Wirtshaus im joHanns Hof. Här får du den mest rustika och traditionella tyska mat du kan tänka dig. Jag tar en episk Schweinshaxe och Tanja en hel rökt forell. En turistfälla men med charm och passion bakom matlagningen.&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_17.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_17-1030x579.jpg" alt="" class="wp-image-33171"/></a><figcaption class="wp-element-caption">Varje morgon borde inledas med en vandring i ett berg – med fotoförbud.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_18.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_18-1030x579.jpg" alt="" class="wp-image-33172"/></a><figcaption class="wp-element-caption">Laddplats med utegym, äntligen! </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_19.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_19-1030x687.jpg" alt="" class="wp-image-33173"/></a><figcaption class="wp-element-caption">Laddkaos i semestertider? Knappast!</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_20.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_20-1030x579.jpg" alt="" class="wp-image-33174"/></a><figcaption class="wp-element-caption">Benediktiner Wirtshaus im joHanns Hof – supertyskt och superrustikt.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_21.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_21-1030x579.jpg" alt="" class="wp-image-33175"/></a><figcaption class="wp-element-caption">Äntligen Meute-konsert! Joakim har väntat sedan 2019. </figcaption></figure>



<p class="has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background has-background has-medium-font-size"><strong>Dag </strong>5 – 3 augusti</p>



<p class="has-very-light-gray-to-cyan-bluish-gray-gradient-background has-background"><strong>Sträcka:</strong> Weimar–Jena–Weimar.<br><strong>Längd:</strong> 50 km.<br><strong>Laddtid</strong>: –</p>



<p class="has-medium-font-size"><strong>På vägen:</strong></p>



<p>Andra dagen i Weimar inleds på det överdådiga slottet Belvedere. Avsätt några timmar i den enorma parken.&nbsp;</p>



<p class="has-medium-font-size"><strong>Måltiden:</strong></p>



<p>När hungern kommer, ta en sväng över berg och genom skog till Jena. Här hittar vi Braugasthof Papiermühle. Stabil mat intas under deras flera 100 år gamla lind under vilken Goethe och andra storheter har suttit.&nbsp;<br>Efter maten blir det en svettig promenad upp på utsiktsberget. Från det ser vi stadens karaktäristika runda skyskrapa. På andra sidan dalen står ett av Tysklands 240 Bismarktorn. &nbsp;</p>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-1 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_22.jpg"><img data-id="33176" src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_22-687x1030.jpg" alt="" class="wp-image-33176"/></a><figcaption class="wp-element-caption">Orangeri på Beldevere.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_23.jpg"><img data-id="33177" src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_23-687x1030.jpg" alt="" class="wp-image-33177"/></a><figcaption class="wp-element-caption">Parken som tillhör slottet Beldevere är värd många timmar. Ladda ner appen från Weimar och lyssna på bra 
historiebeskrivning. </figcaption></figure>
</figure>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-2 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_24.jpg"><img data-id="33178" src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_24-687x1030.jpg" alt="" class="wp-image-33178"/></a><figcaption class="wp-element-caption">Skugga i gångarna runt Belvedere.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_25.jpg"><img data-id="33179" src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_25-687x1030.jpg" alt="" class="wp-image-33179"/></a><figcaption class="wp-element-caption">Ett Bismarktorn.</figcaption></figure>
</figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_26.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_26-1030x513.jpg" alt="" class="wp-image-33180"/></a><figcaption class="wp-element-caption">Objektivt är detta Jena. Roligt om man förstår vad Carl Zeiss tillverkar. </figcaption></figure>



<p class="has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background has-background has-medium-font-size"><strong>Dag </strong>6 – 4 augusti</p>



<p class="has-very-light-gray-to-cyan-bluish-gray-gradient-background has-background"><strong>Sträcka:</strong> Weimar–Berlin.<br><strong>Längd:</strong> 280 km.<br><strong>Laddtid</strong>: 22 min.</p>



<p class="has-medium-font-size"><strong>På vägen:</strong></p>



<p>Var tog vackra Tyskland vägen? Ja, förutom att vi kör igenom ett enormt skyfall med noll sikt och svåra olyckor, är utsikterna och de vackra miljöerna som bortblåsta. Det känns som vi åker mil efter mil genom industriområden och logistikcentrum.</p>



<p>Vi laddar på Ionity Bitterfeld-Wolfen. Mönstret är detsamma: en enorm hubb för tankning/laddning för personbilar och långtradare. Spelhall, check!&nbsp;</p>



<p>Därefter tar Berlins förorter heller aldrig slut. Som sagt, välj inte ”Undvik motorväg” på din navigation när du närmar dig en storstad. Kanske är det vår hunger som spelar in, för när man är i Berlin äter man ju …</p>



<p class="has-medium-font-size"><strong>Boendet:</strong>&nbsp;</p>



<p>Full koncentration nu! Hotellet heter Amo by Amano, inte Amano eller Mani by Amano eller Zoe by Amano eller Amano Home. Sök rätt från början så slipper du köra fel …<br>Amo ligger hursomhelst i ett nybyggt affärskvarter skapligt nära Hackescher Markt. Vi får ett mysigt rum med egen entré på innergården. Mörkt, trångt och trendigt – typiskt Berlin. Grym frukost!</p>



<p class="has-medium-font-size"><strong><br>Måltiden:</strong></p>



<p>… nej, man äter inte currywurst i Berlin. Man äter givetvis dönerkebab. Alibaba Bistro nära Alexanderplats är välbesökt och med högt onlinebetyg. Vi blir inte besvikna och dricker givetvis ayran till.&nbsp;</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_27.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_27-1030x579.jpg" alt="" class="wp-image-33181"/></a><figcaption class="wp-element-caption">Varje tysk by med minst 300 invånare har ett frivilligt brandförsvar. Rekryteringen börjar redan i förskolan!</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_28.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_28-1030x579.jpg" alt="" class="wp-image-33182"/></a><figcaption class="wp-element-caption">En frikadell och en spelhall – om tysken själv får bestämma (vad en rastplats behöver). </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_29.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_29-1030x579.jpg" alt="" class="wp-image-33183"/></a><figcaption class="wp-element-caption">Det svarta fåret är rött &#8230; 
Dodge Challenger Hellcat 
möter två potenta elbilar. </figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_30.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_30-1030x579.jpg" alt="" class="wp-image-33184"/></a><figcaption class="wp-element-caption">Har du sett Babylon Berlin på SVT? Meute spelar i tv-serien.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_31.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_31-1030x579.jpg" alt="" class="wp-image-33185"/></a><figcaption class="wp-element-caption">Berlin är dönerkebab, inte currywurst!</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_32.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_32-1030x579.jpg" alt="" class="wp-image-33186"/></a><figcaption class="wp-element-caption">Lotus Eletre drog blickarna till sig, även i Berlin. </figcaption></figure>



<p class="has-luminous-vivid-amber-to-luminous-vivid-orange-gradient-background has-background has-medium-font-size"><strong>Dag </strong>7/8 – 5–6 augusti</p>



<p class="has-very-light-gray-to-cyan-bluish-gray-gradient-background has-background"><strong>Sträcka:</strong> Berlin–Travemünde&nbsp;+ Helsingborg– Roslagen.<br><strong>Längd:</strong> 300 + 720 km.<br><strong>Laddtid</strong>: 21 + 70 min.</p>



<p class="has-medium-font-size"><strong>På vägen:&nbsp;</strong></p>



<p>Norr om Berlin är Tyskland vackert igen. Djupa skogar och charmiga jordbrukssamhällen. Vi stannar i lilla Teschendorf och njuter både currywurst och bockwurst vid en kiosk.</p>



<p>Sedan väntar laddning i Heiligengrabe, där Ionity har satt upp sin första laddstation med tak, fikabord, lounge och toaletter. Dessutom avskilt från Autobahns jätteanläggningar. Här träffar vi dessutom ägaren till Tysklands första Lotus Eletre, den enda (förutom vår) som vi ser på hela resan. Skoj!</p>



<p>Som avslutning vill jag överraska Tanja med ännu ett slott. Hon älskar verkligen dessa. Slottet i Schwerin räknas som ett av Europas viktigaste historiska byggnadsverk och har dessutom en svenskkoppling. Grevskapet köptes nämligen 1358 av Albrekt II av Mecklenburg, gift med svenska prinsessan Eufemia Eriksdotter och far till svenske kungen Albrekt II av Mecklenburg.&nbsp;<br>I år blev slottet ett Unesco-världsarv och det pågår även en fasadrenovering. Det är lite oklart när arbetet är klart, men det är alltjämt en imponerande plats.</p>



<p>Strax innan färjeläget i Travemünde finns en kort betalväg i form av Herrentunnel. Ha dina mynt redo!&nbsp;I hamnen är det något oklar skyltning mellan TT-Line och Finnlines. Som nämndes i inledningen var det glest med personbilar på färjan, semestertider till trots.&nbsp;Efter en god natts sömn är det prima att vakna med fulladdad bil. Detta kan verkligen rekommenderas!&nbsp;</p>



<p>Tre laddstopp senare (Sverige är verkligen långt, om man bor norr om Stockholm …) var vi åter hemma i Roslagen. Det blev 300 mil på en vecka, i bästa tänkbara komfort. Eletre har, efter några uppdateringar, blivit en långt bättre bil än när vi testade den i februari.&nbsp;<br>Faktum är vi gjorde det för lätt för oss. Nästa år tänker jag välja en bil med kortare räckvidd och sämre laddprestanda. Som elbilsbilist vill jag ju ha spänning på resan …</p>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_33.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_33-1030x579.jpg" alt="" class="wp-image-33187"/></a><figcaption class="wp-element-caption">Gatukök, fast på tyska.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_34.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_34-1030x579.jpg" alt="" class="wp-image-33188"/></a><figcaption class="wp-element-caption">I Heiligengrabe har Ionity har satt upp sin första laddstation med tak, fikabord, lounge och toaletter. Dessutom avskilt från Autobahns jätteanläggningar.</figcaption></figure>



<figure class="wp-block-gallery has-nested-images columns-default is-cropped wp-block-gallery-3 is-layout-flex wp-block-gallery-is-layout-flex">
<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_35.jpg"><img data-id="33189" src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_35-687x1030.jpg" alt="" class="wp-image-33189"/></a><figcaption class="wp-element-caption">Undvik Autobahn – och de sista kilometrarna till laddstationer kan bli en öde överraskning.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_36.jpg"><img data-id="33190" src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_36-687x1030.jpg" alt="" class="wp-image-33190"/></a><figcaption class="wp-element-caption">Svensk-  slottet  i Schwerin. </figcaption></figure>
</figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_37.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_37-1030x579.jpg" alt="" class="wp-image-33191"/></a><figcaption class="wp-element-caption">I år blev slottet i Schwerin ett Unesco-världsarv och det pågår även en fasadrenovering</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_38.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_38-1030x579.jpg" alt="" class="wp-image-33192"/></a><figcaption class="wp-element-caption">Elbilsladdning på TT-Line kan starkt rekomenderas.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_39.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_39-1030x579.jpg" alt="" class="wp-image-33193"/></a><figcaption class="wp-element-caption">En sista Ionity-laddning i Södertälje. Totalt gick det åt 640,53 kWh.</figcaption></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_40.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_40-1030x579.jpg" alt="" class="wp-image-33194"/></a><figcaption class="wp-element-caption">Nästan 300 härliga mil avklarade!</figcaption></figure>



<figure class="wp-block-table is-style-stripes"><table class="has-fixed-layout"><tbody><tr><td><strong>Datum</strong></td><td><strong>Plats</strong></td><td><strong>kWh</strong></td><td><strong>Minuter</strong></td></tr><tr><td>30 juli, 11.35</td><td>Mantorp</td><td>60,13</td><td>17,49</td></tr><tr><td>30 juli, 13.38</td><td>Ljungby Nord</td><td>66,84</td><td>19,36</td></tr><tr><td>30 juli, 16.47</td><td>Malmö</td><td>10,94</td><td>4,15</td></tr><tr><td>31 juli, 11.37</td><td>Vordingborg</td><td>76,03</td><td>20,18</td></tr><tr><td>1 augusti, 12.10</td><td>Lüneburge Heide (W)</td><td>70,88</td><td>23,18</td></tr><tr><td>2 augusti, 14.00</td><td>Sangerhausen</td><td>64,57</td><td>23,29</td></tr><tr><td>4 augusti, 12.19</td><td>Bitterfeld-Wolfen</td><td>63,01</td><td>22,16</td></tr><tr><td>5 augusti, 15.33</td><td>Heiligengrabe</td><td>61,74</td><td>21,45</td></tr><tr><td>6 augusti, 09.45</td><td>Ljungby Syd</td><td>51,76</td><td>26,46</td></tr><tr><td>6 augusti, 12.01</td><td>Mantorp</td><td>55,03</td><td>18,15</td></tr><tr><td>6 augusti, 16.48</td><td>Södertälje</td><td>22,62</td><td>7,58</td></tr><tr><td>6 augusti, 17.02</td><td>Södertälje</td><td>36,98</td><td>18,36</td></tr><tr><td><strong>TOTALT</strong></td><td></td><td><strong>640,53</strong></td><td><strong>221,81</strong></td></tr></tbody></table></figure>



<figure class="wp-block-image size-large"><a href="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_41.jpg"><img src="https://elbilen.se/wp-content/uploads/2024/11/lotus_euro_tour_41-1030x1030.jpg" alt="" class="wp-image-33195"/></a><figcaption class="wp-element-caption"> Åtta dagar och 2.393,2 km med en snittförbrukning på 2,32 kWh/mil. Ynka 3 timmar och 40 minuter av semestern tillbringade vid en laddstolpe. Samtliga laddningar med Ionity fungerade utmärkt. Enda dramatiken på resan var en skakig inledning på grund av undermålig service från Scandlines. Tveka inte på att köra elbil genom Tyskland – men skippa Autobahn.</figcaption></figure>
