
<p class="has-drop-cap">1När Kronprinsessan Victoria och Daniel Westling skulle gifta sig en lördagseftermiddag den 19 juni 2010 var goda råd dyra. Hur skulle en sådan krock påverka <strong>Bodentravets</strong> viktigaste tävlingsdag på året? Lösningen blev början på vad som blivit en tradition i mitten av juni varje år med midnattstrav och V75 på kvällen.<br>Ikväll (första start 18.35) är det dags för årets travfest under midnattssolen med Grupp I-loppet Norrbottens Stora Pris som höjdpunkt med en miljon kronor till vinnaren.</p>



<p>Årets upplaga håller hög klass och vinnaren i spårlottningen är dubble Norrbottens Stora Pris-vinnaren <strong>Francesco Zet</strong> (e. Father Patrick).<br>– Francesco Zet var det härligt att se i Paralympiatravet och han vann på topptid utan att vara helt tom i mål. Han fick stå över elitloppshelgen och siktet har varit mot denna helg och som han känns i jobben bör han vara på samma nivå som på Åby. Jag körde lite tuffare med honom i måndags och allt var som det skulle. Han kommer göra ett bra lopp och läget blev väldigt bra. Det blir barfota runt om bike, säger Daniel Reden på sin hemsida reddis.se.</p>



<p>Främste utmanaren är nybakade Elitloppsfyran <strong>Jobspost</strong> (e. Readly Express) från Jörgen Westholms stall.<br>– Jobspost var enorm i Elitloppet. Hästen har tagit det jättebra och jag tänker att han till och med kan ha gått framåt av det här upplägget. Formkurvan pekar tydligt uppåt. Men jag är nöjd bara han visar samma form som i Elitloppet! säger Jörgen Westholm till Kanal75.</p>



<p>Daniel Wäjerstens <strong>Gio Cash</strong> (e. Victory Gio) är titelförsvarare och travade 1.10,8a/2.140 meter vid fjolårets seger, vilket är näst snabbaste tiden i loppets historia.</p>



<p><strong>Fem snabbaste vinnarna i Norrbottens Stora Pris</strong><br><em>År, häst (far) – Kusk (tränare) – Segertid</em></p>



<ul class="wp-block-list">
<li>2024 <strong>Francesco Zet</strong> (e. Father Patrick) – Örjan Kihlström (Daniel Redén) – 1.10,7a</li>



<li>2025 <strong>Gio Cash</strong> (e. Victor Gio) – Daniel Wäjersten – 1.10,8a</li>



<li>2017 <strong>Oasis Bi</strong> (e. Toss Out) – Kim Eriksson (Stefan P Pettersson) – 1.10,8a</li>



<li>2023 <strong>Francesco Zet</strong> (e. Father Patrick) – Örjan Kihlström (Daniel Redén) – 1.11,0a</li>



<li>2020 <strong>Antonio Tabac</strong> (e. Crazed) – Mika Forss (Jörgen Westholm) – 1.11,1a</li>
</ul>



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



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



<p class="has-drop-cap">2Halva vinstpotten förra lördagen – eller 24.662.571 kronor för att vara exakt – brann inne på V85-spelet, där det efter favoritparad varken blev utdelning på fem eller sex rätt. Hela summan flyttas över till kvällens åttarättspott – spelstopp klockan 20.10 – som spås landa på minst 47 miljoner kronor.</p>



<p>Sulkysports expertpanel har som vanligt plockat fram godbitarna och levererar sina bästa spikar och skrälldrag. Här är ett av spikförslagen:<br><em>”<strong>Mace Windu</strong> (V85-5) gjorde årsdebut och första starten som valack för ett par veckor sedan. Han fick ett bra lopp, men klev undan på ett riktigt snyggt sätt till slut. Bra inne på pengarna och känns väldigt bra för lägsta STL-klassen. Bra läge och lopp i kroppen och han är en häftig chanspik till härligt spelvärde.”</em></p>



<p>Så här säger tränaren Daniel Redén själv om hästen på sin hemsida:<br>– Mace Windu gjorde första starten som valack senast och det var en bra insats han svarade för och det var kul att se då det är en fin häst som inte fick någon direkt utdelning ifjol. Han var stark i måndagsjobbet och läget blev passande. Det blir samma balans som senast, det vill säga barfota bak, säger Daniel Redén.</p>



<p><a href="https://sulkysport.se/spelstugan/v85-jackpot-experternas-drag/" target="_blank" rel="noreferrer noopener">––> Här är experternas tips till Bodens dubbeljackpot på V85.</a></p>



<p><em>Vill du spela andelsspel tillsammans med Sulkysports panel? Här finns olika alternativ:</em></p>



<p><a href="https://www.atg.se/butik/simsalabim/V85_2026-06-13_11_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Simsalabim.</a></p>



<p><a href="https://www.atg.se/butik/69ansspel/V85_2026-06-13_11_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos 69:ans Spel &#038; Tobak.</a></p>



<p><a href="https://www.atg.se/butik/spelpoolen/V85_2026-06-13_11_5" target="_blank" rel="noreferrer noopener">Här finns andelar till V85 hos Spelpoolen.</a></p>



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



<p class="has-drop-cap">3Hemmatränarna laddar alltid extra inför banans största tävlingsdag för året, men det har ”bara” blivit tre segrar på de 21 V75-loppen de senaste tre åringen. Den gemensamma nämnaren är Roger Nilsson som tränade två vinnare 2023 och enda Bodenvinnare förra året.</p>



<p>Ikväll har Roger fyra hästar till start inom V85-spelet. En av dem är <strong>Filling Fuel</strong> (e. Panne de Moteur), som förra året vann ett dubbelklasslopp tillsammans med Örjan Kihlström just denna tävlingsdag.<br>– Filling Fuel känns fin. Det är en spårtrappa och läget har man betalat för. Jag hoppas att det löser sig för honom, i så fall kan han vara långt framme. Nu växlar jag upp balans och utrustning. Det blir barfota runt om och amerikansk vagn, sedan byter jag ut det helstängda huvudlaget mot kupor, säger Roger Nilsson till Kanal75.</p>



<p>En lång travdag i Sverige inleds på förmiddagen på <strong>Romme</strong> (första start 11.10), där det är en av fyra tävlingsdagar förbehållna kuskar födda 2001 eller senare. Det var premiär för konceptet ”Unga kuskar” förra året och i år har en dag genomförts på Dannero i maj. I augusti blir det samma upplägg i Vaggeryd (9 augusti) och Eskilstuna (29 augusti).</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2026/06/260613.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till lördagens 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/2025/10/yotillie102525newimagemedia1024px-617x347.jpg" alt="" class="wp-image-785744"/><figcaption class="wp-element-caption">Yo Tille och Todd McCarthy. Foto: New Image Media</figcaption></figure>



<p class="has-drop-cap">4 Kanadas stora kväll för sulkysporten inträffar idag, på Woodbine utanför Toronto, dit stora stjärnor söker sig för väldigt intressanta uppgörelser. Goodtimes Final (C$240.000) för treåriga hingstar och valacker har lockat elva hästar till start och från svenskt håll kommer både Marcus Melander och Åke Svanstedt att vara med. </p>



<p>Melander selar ut Stall Courants <strong>Neighver Punt </strong>(e. Bar Hopping-Twice Is Right) medan Svanstedt mönstrar<strong> Magic Punk</strong> (e. Wishing Stone-I D Entity NO) och det var just dessa två hästar som tog hem försöken till Goodtimes Final. </p>



<p>Ett snabblopp för travare sticks in under tävlingskvällen och där dyker svenske <strong>Aetos Kronos</strong> (e. Bold Eagle) upp bland välmeriterade konkurrenter. Yonkers International-vinnaren <strong>Lexus Kody</strong> (e. Archangel), Nancy Takters <strong>French Wine</strong> (e. Bar Hopping) och Elitloppshästen <strong>Logan Park</strong> (e. Archangel) är några av de tuffare motbuden till Aetos Kronos.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/04/loganparkapril142025newimagemedia1024px-617x347.jpg" alt="" class="wp-image-707045" style="width:518px;height:auto"/><figcaption class="wp-element-caption">Logan Park och Doug McNair. Foto: New Image Media</figcaption></figure>



<p>Första starten för året gör Åke Svanstedts <strong>Warrawee Michelle</strong> (e. Walner) när Armbro Flight Final (C$215.000) ska avgöras för äldre ston. Bland motståndarna riktas blickarna mot Andrew Harris-tränade <strong>Yo Tillie</strong> (e. Tactical Landing), som avslutade fjolåret med seger i Breeders Crown-finalen för treåriga ston.</p>



<p>Åke Svanstedts <strong>Dial Square</strong> (e. Ready Cash) och <strong>Nelsonbriteagle NO</strong> (e. Bold Eagle) gör, tillsammans med Marcus Melanders <strong>Bourbonista S</strong> (e. Face Time Bourbon), Per Engbloms <strong>Bravo Angel </strong>(e. Readly Express) och Nancy Takters <strong>Champagne Problems</strong> (e. Tactical Landing) till ett svenskt övertag i Armbro Flight.</p>



<h2 class="wp-block-heading">Startlista Goodtimes Final</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li><strong>Strobe Lite</strong> (e. Alarm Detector) – Benoit Baillargeon</li>



<li><strong>Wolfpack Crown</strong> (e. Six Pack) – Tyler Moore</li>



<li><strong>Magic Punk</strong> (e. Wishing Stone) – Åke Svanstedt</li>



<li><strong>Touchedbyanangel</strong> (e. Archangel) – Robert Fellows</li>



<li><strong>Neighver Punt</strong> (e. Bar Hopping) – Marcus Melander</li>



<li><strong>Dream For Peace</strong> (e. Muscle Mass) – Shawn Steacy</li>



<li><strong>Land The Plane</strong> (e. Tactical Landing – Carl Jamieson</li>



<li><strong>Royal Captain</strong> (e. Captain Corey) – Dustin Jones</li>



<li><strong>Classified</strong> (e. Captain Corey) – Matthew Bax</li>



<li><strong>Greenarrow Hanover</strong> (e. Greenshoe) – Shawn Steacy</li>



<li><strong>I Am</strong> (e. Readly Express) – Herb Holland</li>
</ol>



<h2 class="wp-block-heading">Startlista Armbro Flight Final</h2>



<p>Häst (far) – Tränare</p>



<ol class="wp-block-list">
<li><strong>Stormont Beautiful</strong> (e. Resolve) – Kevin Benn</li>



<li><strong>Monalishi</strong> (e. Green Manalishi) – Blake MacIntosh</li>



<li><strong>Kadiddle</strong> (e. Kadabra) – Jerry Duford</li>



<li><strong>Warrawee Michelle</strong> (e. Walner) – Åke Svanstedt</li>



<li><strong>Nelsonbriteagle NO</strong> (e. Bold Eagle) – Åke Svanstedt</li>



<li><strong>Yo Tillie</strong> (e. Tactical Landing) – Andrew Harris</li>



<li><strong>Dial Square S</strong> (e. Ready Cash) – Åke Svanstedt</li>



<li><strong>Bravo Angel </strong>(e. Readly Express) – Per Engblom</li>



<li><strong>Bourbonista S</strong> (e. Face Time Bourbon) – Marcus Melander</li>



<li><strong>Champagne Problems</strong> (e. Tactical Landing) – Nancy Takter</li>



<li><strong>Miracle Maven</strong> (e. Dont Let’em) – Ron Burke</li>
</ol>



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



<p class="has-drop-cap">5 Igår <a href="https://sulkysport.se/tva-for-tva-pa-vincennes/" target="_blank" rel="noreferrer noopener">Vincennes</a>, idag Enghien och förhoppningar om fler svenska framgångar i Paris. Under fredagskvällen var det Jörgen Westholms <strong>Leaderboard</strong> (e. Face Time Bourbon) som tog andra raka triumfen på Vincennes och idag hoppas Joakim Elfving på första segern i Frankrike för femårige <strong>Phantom Express</strong> (e. Readly Express), som är en av två svensktränade hästar i Prix New York (€90.000) som körs över 2.150 meter och startas med bil.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/08/7phantomexpress-617x333.jpg" alt="" class="wp-image-618981"/><figcaption class="wp-element-caption">Joakim Elfvings Phatom Express finns med i Prix New York på Enghien idag. Foto: Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Den andre svenskhästen i loppet är Jörgen Westholms <strong>Indy Rock</strong> (e. Readly Express), som kommer från tre vårstarter i den nya regin. Indy Rock vann lopp på Vincennes under vintermeetinget 2024/2025, men har därefter haft svårt att få till det i Paris. Nu gör hästen debut på Enghien och kanske kan det miljöombytet visa sig vara rätt.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/02/munich1-617x344.jpg" alt="" class="wp-image-685757" style="aspect-ratio:1.7936507936507937;width:585px;height:auto"/><figcaption class="wp-element-caption">Indy Rock och Paul-Philippe Ploquin vid seger i Prix de Munich på Vincennes. Foto: Gerard Forni</figcaption></figure>



<p>Mer svenskt blir det senare under tävlingsdagen på Enghien. I Prix de Balmont (€53.000) startar Maria Törnqvist <strong>Ever So Much</strong> (e. Maharajah) och <strong>Fashion Monger</strong> (e. Panne de Moteur) där man ställs mot Markus B Svedbergs<strong> Michigan Bro</strong> (e. S.J.&#8217;s Caviar).</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260612kl.21.31.31-617x330.jpg" alt="" class="wp-image-861567"/><figcaption class="wp-element-caption">Lassas Vårvina kopplar grepp och vinner Jenny R.G:s Minne i Bollnäs. Skärmbild ATG-live</figcaption></figure>



<p class="has-drop-cap">6 Vid Bollnäs kvällstävlingar igår avgjorde Jenny R.G:s Minne för kallblodsston och 100.000 kronor väntade vinnaren av loppet. Det blev en imponerande triumf för Joel Wennströms femåring <strong>Lassas Vårvina</strong> (e. Art Kjarvald), styrd av Ole Johan Östre och ekipaget fick verkligen göra det tunga jobbet för att bärga segern.</p>



<p>Lassas Vårvina fick ge sig iväg i tredjespår varvet från mål och blev kvar där resten av loppet. Likväl sluggade hon sig till knapp seger på 1.29,6/2.140 meter. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/06/skarmavbild20260612kl.21.54.55-617x343.jpg" alt="" class="wp-image-861569"/><figcaption class="wp-element-caption">Global Grand Slam vinner trots galopp. Skärmbild ATG-live</figcaption></figure>



<p>Traditionella Tillmans-Duellen i två heat där B- och K-licensinnehavare möter A-tränare i final blev en rafflande historia där Oskar Kylin Blom drog längsta strået bakom egentränade<strong> Global Grand Slam</strong> (e. Charly du Noyer), vilken också vann sitt försök tidigare under kvällen. </p>



<p>Global Grand Slam gjorde bort sig med galopp innan bilen släppte fältet och Kylin Blom lyckades få sin häst i rätt gångart och sedermera lotsa fram fyraåringen till vinst på 1.13,1a/1.640 meter.</p>



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



<p class="has-drop-cap">7 Tillbaka till Kanada och Woodbine, för det är inte bara travarna som ska slåss om stora pengar. Pepsi North America Cup (C$1.000.000) för treåriga passgångare är utan tvekan kvällens höjdpunkt och två av Amerikas stora snackhästar i sulkysporten drabbar åter samman när finalen avgörs i kväll. Dr Ian Moores <strong>Beau Jangles</strong> (e. Cattlewash) hade 15 raka segrar från debuten när han i senaste framträdandet – i försök till NA Cup – stötte på patrull i form av den andra heta hästen bland treåringar i Amerika:<strong> Odds On Mr Mamba</strong> (e. Odds On Equuleus). </p>



<p>Odds On Mr Mamba har inget dåligt facit han heller. Tio starter i livet har resulterat i nio vinster och i kväll kommer första svaret på vem som är kullens kung bland treåringarna.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2018/01/burkeron12-617x288.jpg" alt="" class="wp-image-17955" style="width:378px;height:auto"/><figcaption class="wp-element-caption">Ron Burke. Foto Simon Hagen/stalltz.se</figcaption></figure>



<p>De treåriga stona gör upp i Fan Hanover Final (C$420.000) där Ron Burkes <strong>Loua Dipa</strong> (e. Sweet Lou) kommer till start som favorit efter tio segrar på 15 försök.</p>



<p>Vi kan hålla oss kvar på den nordamerikanska kontinenten ett litet tag till. Det körs nämligen två lopp i Ohio Sire Stakes ($75.000) för treåringar på Scioto Downs och Anette Lorentzon har lockat Tim Tetrick till &#8221;The Buckeye State&#8221; för att köra favoriten i det ena av de två loppen, <strong>Big Ranger</strong> (e. In Range).</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/09/bigrangere1758078343244-617x399.jpg" alt="" class="wp-image-768806" style="width:510px;height:auto"/><figcaption class="wp-element-caption">Big Ranger vid en tidigare seger. Foto: Conrad Photo</figcaption></figure>



<p>Det är In Range och Ready For Moni som dominerar som avelshingstar bland de treåriga travarna i Ohio idag och mycket talar för att just dessa två hingstar kommer att se sina avkommor i vinnarcirkeln på Scioto Downs,</p>

Fokustema
Sju nyheter vid sju
Läs senare
Vem får segerdefilera i nattsolen?
Francesco och grabbarna synar midnattssolen i Boden. 24 miljoner extra till V85-potten.
Ordnar Roger hemmaseger som vanligt? Från Vincennes igår till Enghien idag där en Phantom dyker upp.
Kanadas stora sulkydag, det är idag.
Där är några av punkterna i dagens Sju nyheter vid sju.
Ordnar Roger hemmaseger som vanligt? Från Vincennes igår till Enghien idag där en Phantom dyker upp.
Kanadas stora sulkydag, det är idag.
Där är några av punkterna i dagens Sju nyheter vid sju.
