
<p class="has-drop-cap">1Breeders Crown-försök spetsat med hemmahjälten On Track Piratens egna lopp. Rättvik (första start 13.45) bjuder på sedvanligt starka tävlingar på midsommardagen med gott om fyrbenta profiler i startlistorna.</p>



<p>Försöket för de fyraåriga hingstarna och valackerna är en riktig höjdare. Här finns främst David Perssons <strong>Nightlife In</strong> (e. Day Or Night In), vann korta E3 och slutade tvåa i långa versions ifjol, och Daniel Redéns <strong>Perfect Chest</strong> (e. Perfect Spirit) följde upp andraplatsen i Svenskt Travkriterium med att vinna Breeders Crown.<br>Duon väntar fortfarande på första fullträffen under Derbysäsongen, där Nightlife In har en tredjeplats som bäst på tre försök och Perfect Chest tog samma placering i årsdebuten i Visby.</p>



<p>Försöket för de fyraåriga stona går inte heller av för hackor. Fredrik Wallins trippelmiljonärska <strong>Bonsee Garde</strong> (e. Makethemark) – seger i korta E3, tvåa i Breeders Crown och trea i Oaks ifjol – ställs mot norska Kriterievinnaren <strong>Catchgaga Volo</strong> (e. Googoo Gaagaa) och svenska miljonärskorna Mamma Mia Sisu (e. Walner) och <strong>Love to the Limit</strong> (e. Bold Eagle).</p>



<p>On Track Piratens lopp då? Ja, Paul Hagoorts nioåring <strong>Hades de Vandel</strong> (e. Ganymede) har skapat ett trevligt svenskt midsommarfirande när han vunnit loppet två år i rad. Ifjol travade han starka 1.10,1a/2.140 meter när han lade beslag på lagerkransen trots galopp. Året före ”räckte” 1.10,5a. Hades de Vandel kommer närmast från finalplats i Sweden Cup (oplacerad där efter andraplats i försöket).</p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/04/goopolle-617x333.jpg" alt="" class="wp-image-291801"/><figcaption class="wp-element-caption">Olle Goop. Foto Mia Törnberg/Sulkysport</figcaption></figure>



<p class="has-drop-cap">2Olle Goops minne hedras också med ett ungdomslopp i Rättvik. När Olle Goop blev proffs 1967 var Rättvik hemmabanan. Som tränare räknade han in 7.696 segrar, medan han bokförde sig för 6.745 vinster i sulkyn. Olle Goop gick bort 20 april 2022 i en ålder av 78 år.<br>I hans minneslopp i Rättvik gör tolv kuskar födda 2001 eller senare upp om 40.000 kronor i förstapris.</p>



<p>I samband med Olle Goops bortgång startades insamling av medel för att ombilda Björntaget till en stiftelse i Olle Goops Minne efter önskemål från familjen Goop. Nu är det hög tid för privatpersoner eller skolor att söka bidrag från Olle Goops Minne, där sista ansökningsdag är 30 juni.</p>



<p><a href="https://www.travsport.se/arkiv/nyheter/2026/juni/sok-bidrag-fran-olle-goops-minne-ansokan-ar-oppen-till-30-juni" target="_blank" rel="noreferrer noopener">Läs mer om Olle Goops Minne här!</a></p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2020/07/frickjim-617x468.jpg" alt="" class="wp-image-102132"/><figcaption class="wp-element-caption">Jim Frick. Foto: Stefan Melander/stalltz.se</figcaption></figure>



<p>En annan stor profil från Dalarna var Jim Frick, som gick bort 25 juli 2020, 68 år gammal. Familjen startade en stipendiefond i Jims namn för att främja ungdomar inom travsporten och i fem år har Jim Fricks stipendium delats ut. Den 14 juli är sista dag att söka årets stipendium på 30.000 kronor.</p>



<p><a href="https://www.travsport.se/arkiv/nyheter/2026/juni/sok-jim-fricks-stipendium-30-000-kronor-for-framtiden" target="_blank" rel="noreferrer noopener">Läs mer om Jim Fricks stipendium här!</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">3En tävlingsdag som inleds på lördagen och avslutas på söndagen. Skellefteås midnattstrav (första start 20.30) gör skäl för namnet när tävlingsdagens elfte och sista lopp startar klockan 00.05.</p>



<p>Midsommarkransen för både varmblod och kallblod är två styrkeprov över drygt tre varv och hästar på flera volter. Helt i Skellefteålegendaren Stig Lindmarks smak. Loppet har körts sedan 1965 och Lindmark vann loppet sju gånger (!) med <strong>Dun Bunter</strong> (e. King Bunter) på 1970- och 1980-talet.<br>Till den segersviten har Sandra Erikssons valack <strong>B.Sacamano</strong> (e. Prodigious) fortfarande en lång bit att vandra, men hästen är ändå en bit på väg. De två senaste åren har det blivit seger och B.Sacamano finns med även i årets upplaga.</p>



<p>Kallblodens upplaga ser Jan-Olov Persson-tränade <strong>Pyrotek</strong> (e. Tekno Odin) som fältets ende miljonär. Nu ska hästen och Marcus Lilius försöka lösa uppgiften från 60 meters tillägg. </p>



<p>Midsommarkransen för ston är ett varv kortare och ser flera V85-härdade ston i fältet. Förstapriserna i alla tre lopp är 75.000 kronor.</p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">475.000 kronor väntar vinnaren när det är försök och final i Lindesberg (första start 12.20). Midsommarloppet är namnet och två försök över sprinterdistans ger 14 finalister som möts över medeldistans på två volter.<br>Robert Bergh kommer med ett starkt kort i vardera avdelning i <strong>Ni No Noix</strong> (e. Charly du Noyer), som vann i Berghdebuten för två veckor sedan, och <strong>Love To Know</strong> (e. Love You)med en fin vår bakom sig.<br>Den sistnämnde möter <strong>Staro Royal Mark</strong> (e. Maharajah), som travade 1.10,8ak som trea i årsdebuten och är lillebror till tolvfaldige miljonären Makethemark.</p>



<p>En av landets sommarbanor med tre tävlingsdagar vardera drar igång traditionsenligt på midsommardagen när Oviken (första start 14.00) bjuder in till årspremiär.<br>Där gör bland annat en av deltagarna i Kallsvenskan tävlingsdebut när Freddrik Fransson plockar ut sin treåring <strong>Karl Otto</strong> (e. B.W.Modde).</p>



<p>Oviken tävlar även den 28 juni och 19 juli och sommarens största lopp är Ovikens Kalla med försök och final samma dag nästa söndag. I finalen väntar 50.000 kronor på vinnaren. </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/260620.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till midsommardagens tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/peteruntersteiner-617x333.jpg" alt="" class="wp-image-452165"/><figcaption class="wp-element-caption">Peter Untersteiner. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap">5Johan Untersteiner har ett Derbyhopp i <strong>Lazy Dust</strong> (e. Brillantissime), som förra året slutade tvåa i danska Kriteriet. Idag väntar säsongens första stora uppgift när det är final i Jydsk 4-årings Grand Prix i Århus. Förstapriset är hela 311.000 danska kronor, eller drygt 450.000 svenska kronor.</p>



<p>Lazy Dust vann sitt försök tillsammans med tränarfadern Peter, som sitter i vagnen även i finalen. Övriga försöksvinnare var <strong>Lee Marvin</strong> (e. Nuncio), <strong>Lonesomerider</strong> (e. Power) och <strong>Lemmy</strong> (e. Traders).<br>Ytterligare en svensktränad häst nådde final, Christoffer Erikssons <strong>La Liga Boy</strong> (e. Donato Hanover).</p>



<p>Stona tävlar om 184.000 danska kronor i förstapris och stor favorit blir en av vinnarna i uttagningsloppen, <strong>Lipa Wee</strong> (e. Tactical Landing), som vann Stokriteriet förra året. De andra försöken vanns av <strong>Leonora</strong> (e. Ens Snapshot) och <strong>Lux</strong> (e. Maharajah).</p>



<p>I snabbloppet över 1.800 meter med 60.000 danska kronor i förstapris tränar Flemming Jensen fyra av åtta hästar, däribland <strong>Extreme</strong> (e. Chocolatier), som gör tredje starten efter flera skadefyllda år.</p>



<p><a href="https://www.jvb-aarhus.dk/media/xvpjoa0f/aarhus_20-06-26_n.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar i Århus.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">6250.000 norska kronor och eventuellt en biljett till Åby Stora Pris. Det ligger i potten i färska, norska banan Orklas största lopp Nils Arne Eggens Äreslopp vars premiärupplaga vanns av svenskfödde <strong>Oracle Tile</strong> (e. Ready Cash) 2022.</p>



<p>Loppet är en hyllning till norsk fotbolls störste tränare som kom från Orkdal där nya banan ligger och var fotbollsklubben Rosenborgs tränare under många år. Totalt vann Nils Arne Eggen norska ligan 15 (!) gånger som tränare, varav 14 gånger med Rosenborg. Eggen, som avled 2022, hade stort travintresse och var hästägare.</p>



<p>Årets upplaga avgörs över något förkortad distans, då grunddistansen i flerklassloppet kortats från 3.400 till 2.840 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/03/highnonpepperdef-617x333.jpg" alt="" class="wp-image-562289"/><figcaption class="wp-element-caption">High On Pepper. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Det största namnet kommer från Katja Melkkos stall när <strong>High On Pepper</strong> (e. Ready Cash) är tillbaka på banan efter sjundeplatsen i Harper Hanovers lopp. Norges segerrikaste kusk genom tiderna, Eirik Höitomt, sitter upp i vagnen från 40 meters tillägg.<br>På startfållan finns loppets andra svensktränade häst i Markus Pihlströms fyraåring <strong>Jonte Godiva</strong> (e. Who’s Who) tillsammans med Tom Erik Solberg.<br>Hemmahoppet är Geir Vegard Gundersens forne Derbyvinnare <strong>Charron</strong> (e. Cod Bon), som tävlat i Elitloppet två år i rad.</p>



<p>Och när det gäller eventuell biljett i Åby Stora Pris. Får att få den måste segertiden vara 1.13,5 eller snabbare.</p>



<p>Två av stjärnorna från Tröndelag genom åren hedras med varsitt minneslopp. Kallblodsfenomenet <strong>Bork Rigel</strong> – 168 segrar på 345 starter! – och varmblodsstjärnan <strong>Tamin Sandy</strong>, som bland annat vann Orsi Mangelli i Italien som treåring och då besegrade stjärnor som Zoogin, Pine Chip och Toss Out.</p>



<p>Båda loppen har svenska inslag. Jan-Olov Perssons femåring <strong>Hulte Adam</strong> (e. Hulte Magnus) körs av Henrikk Kihle i kallblodsloppet, medan Bergsåkeramatören Marit Beckströms <strong>Phoebe B.R.</strong> (e. International Moni) kommer ut i treåringsloppet för varmblod.</p>



<p><a href="https://www.travsport.no/travbaner/varig-orkla-arena/startlist/2026-06-20" target="_blank" rel="noreferrer noopener">Här är startlistorna till Orklas tävlingar.</a></p>



<p class="has-text-align-center">***</p>



<p class="has-drop-cap">7Ingen svenskfödd häst har vunnit det stora finska kallblodsloppet Nordic King (€90.000) i Härmä sedan premiären 2016. Däremot har det blivit en svensk tränar- och kuskseger när Mats E Djuse måttande in en målfotoseger med Fredrik Fransson-tränade <strong>Odd Herakles</strong> (e. Moe Odin) i 2021 års upplaga.</p>



<p>En svensk tränare reser till Härmä för storloppet när Robert Skoglund startar tioårige dubbelmiljonären <strong>Sundbo Komet</strong> (e. Sundbo Kravall).</p>



<p>Annars talar det mesta för hemmaseger med starka finska kort som Elitkampsvinnarna <strong>Pro</strong> (2026) och <strong>Evartti</strong> (2023), samt de senaste två årens Kungstravsvinnare och fjolårsvinnaren i detta lopp, V.G.Voitto.</p>



<p><strong>Segertider under 1.20 i Nordic King:</strong><br><em>År: Häst (far) – Kusk – Segertid</em></p>



<ul class="wp-block-list">
<li>2018: <strong>Costello</strong> (e. Suikun Ralli) – Risto Tupamäki – 1.19,3a</li>



<li>2021: <strong>Odd Herakles</strong> (e. Moe Odin) – Mats E Djuse – 1.19,4a</li>



<li>2022: <strong>Evartti</strong> (e. K.M.Nopsa) – Santtu Raitala – 1.19,4a</li>



<li>2016: <strong>Jokivarren Kunkku</strong> (e. Turo) – Jorma Kontio – 1.19,9a</li>



<li>2017: <strong>Välähdys</strong> (e. Viesker) – Ville Korjus – 1.19,9a</li>
</ul>



<p>Snabbloppet för varmblod med 20.000 euro till vinnaren ser fem hästar tränade i Sverige i startlistan. Daniel Wäjersten har duon <strong>Zaxton</strong> (e. Trixton) och <strong>Mellby Joker</strong> (e. Muscle Hill), Sandra Eriksson kör egentränade <strong>Devils Tongue</strong> (e. Zola Boko) och Alessandro Gocciadoro lotsar sin <strong>Executive Ek</strong> (e. Face Time Bourbon). Det femte bidraget är Petri Salmela-tränade <strong>Henry Flyer Sisu</strong> (e. Bold Eagle).</p>



<p><a href="https://heppa.hippos.fi/heppa/app?ct=YXBwbGljYXRpb24vcGRm&#038;d=dHJ1ZQ%3D%3D&#038;dr=&#038;f=b2hqZWxtYXRpZWRvdC5IUl8yMC4wNi4yMDI2LnBkZg%3D%3D&#038;m=c2IvioD0hyiAZm546%2BOcGbMDO2E%3D&#038;service=pdftmp" target="_blank" rel="noreferrer noopener">Här är startlistorna till Härmäs tävlingar.</a></p>

Fokustema
Sju nyheter vid sju
Läs senare
Toppduellen i Dalarna
Fyraåringsduell i Rättvik. Så söker du Olle Goops och Jim Fricks stipendium. Trav efter midnatt i Skellefteå. Årspremiär vid fjällen. Svenskar jagar stora prischeckar i tre nordiska länder.
Detta och mer bland midsommardagens nyheter.
Detta och mer bland midsommardagens nyheter.
