
<p class="has-drop-cap wp-block-paragraph">1 Igår handlade det om ston – idag är det dags för klassiska finaler för hingstar och valacker på Bjerke med Derbyt och Kriteriet för båda raserna. Det är en hel del blågult i startlistorna och historiskt sett har det också blivit en del framgångar för svensk del. I Kallblodsderbyt har det blivit tre segrar (Järvsöfaks, Järvsöviking och Tekno Eld) och i Kriteriet två vinster (Tand Kraft och Eld Rask).</p>



<p class="wp-block-paragraph">Gemensam nämnare för kvitetten är tränaren Jan-Olov Persson, som saknar häst i Kriteriet, men däremot har en duo i Norskt Kallblodsderby. Det starkaste kortet är <strong>Hulte Adam</strong> (e. Hulte Magnus), som slutade tvåa bakom <strong>Tangen Martin</strong> (e. Bork Odin) i svenska Derbyt.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2023/08/janolovpersson1-617x333.jpg" alt="" class="wp-image-478960" style="width:333px;height:auto"/><figcaption class="wp-element-caption">Jan-Olov Persson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/lackberg-gar-fore-oslo/">––> Läs mer om Hulte Adam och hans uppfödare Leif Jonsson i en lång intervju här!</a></p>



<p class="wp-block-paragraph">Bergsåkertränaren Robert Skoglund har ett bra år som tränare med flera finalister i de svenska klassikerna, där <strong>Ängsrask</strong> (e. Bork Odin) lyckades bäst med andraplatsen i Kriteriet på Dannero. Nu har han laddat om och kvalat in till den norska upplagan efter seger i försöket tillsammans med Ulf Ohlsson.</p>



<p class="wp-block-paragraph">Fjolårets Kriterievinnare <strong>Gör Som Jag Vill</strong> (e. Järvsö Björn) är Skoglunds hopp i norska Derbyt.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2025/08/robertskoglund2025-617x333.jpg" alt="" class="wp-image-750767" style="width:507px;height:auto"/><figcaption class="wp-element-caption">Robert Skoglund. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Öystein Tjomsland har efter Tangen Martins triumf i Östersund i august åtta raka segrar som tränare i Svenskt Kallblodsderby. I den norska upplagan kan det bli sjunde raka titeln. Den som främst står i vägen är Kjetil Djöseland med fjolårets norske Kriterievinnare <strong>Gigant Tider </strong>(e. Norheim Svenn), som valde innerspår.</p>



<h2 class="wp-block-heading">Svenska finalister – söndag</h2>



<ul class="wp-block-list">
<li><strong>Kriteriet, kallblod – förstapris 450.000 NOK:</strong></li>



<li>Ängsrask (e. Bork Odin) – Ulf Ohlsson (Robert Skoglund)</li>



<li>Troll Rapp (e. Tekno Odin) – Svein Ove Wassberg (Jan Ove Olsen)</li>



<li><strong>Derbyt, kallblod – förstapris 700.000 NOK:</strong></li>



<li>Hulte Adam (e. Hulte Magnus) – Henrik Kihle (Jan-Olov Persson)</li>



<li>Gör Som Jag Vill (e. Järvsö Björn) – Ulf Ohlsson (Robert Skoglund)</li>



<li>B.W.Birger (e. Tekno Jerven) – Eirik Höitomt (Jan-Olov Persson)</li>



<li>Palmesus N.O. (e. Nordsjö Odin) – Öystein Tjomsland</li>
</ul>



<p class="wp-block-paragraph">Fotnot: Öystein Tjomsland har flera finalister, men dessa står på hans norska träningslista.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Norges främste unghästtränare på varmblodssidan är Geir Vegard Gundersen. Tio gånger har han varit inblandad i en norsk Derbyvinnare som tränare och/eller kusk och redan efter förra årets triumf med <strong>Charron</strong> (e. Code Bon) sade ”GV” att han slutar som tränare om han tar en elfte seger. Då skulle han nämligen passera legenden och idolen Gunnar Eggens tio Derbytitlar.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/09/skarmavbild20240908kl.16.21.41-617x347.jpg" alt="" class="wp-image-631309" style="width:489px;height:auto"/><figcaption class="wp-element-caption">Från dödens vinner Nadal B.R. och Magnus Teien Gundersen Norskt Kriterium.</figcaption></figure>



<p class="wp-block-paragraph">Hoppet heter <strong>Nadal B.R. </strong>(e. Googoo Gaagaa), som vann Kriteriet förra året och körs av sonen Magnus, men framför allt Frode Hamre kan sätta käppar i hjulen som tränare bakom de två snabbaste försöksvinnarna <strong>Timestile R.</strong> (e. Readly Express) och <strong>Tix</strong> (e. El Diablo B.R.).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/fokus/livet-gar-vidare-och-hastarna-ar-pa-topp/" target="_blank" rel="noreferrer noopener">––> Läs mer om Geir Vegard Gundersen i en lång intervju här!</a></p>



<p class="wp-block-paragraph">Öystein Tjomsland har radat Derbysegrar på kallblodssidan och har chansen även i varmblodens upplaga genom svenskägde<strong> Felix Halbak</strong> (e. Orladno Vici).</p>



<p class="wp-block-paragraph">På varmblodssidan har det varit svensktränat i topp. I Derbyt syns vinnarna News From Heaven och Muscles Wiking B.R, medan det i Kriteriet blivit hela fem triumfer sedan 2010: Muscles Wiking B.R, El Toto B.R, Shocking Superman, Hard Times och Stoletheshow.</p>



<p class="wp-block-paragraph">De svenska inslagen i varmblodskriteriet sker i form av gästkuskarna Mats E Djuse och Ulf Ohlsson, där Mats kör fältets enda sto <strong>Catchagaga Voo</strong> (e. Googoo Gaagaa) – slog hingstarna i Biris Treåringselit – medan Ulf får chansen bakom<strong> Casanova Dream</strong> (e. Maharajah).</p>



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



<p class="has-drop-cap wp-block-paragraph">3 V75-spel blir det till dagens klassiker på Bjerke, där de fyra finalerna tar plats på kupongen. Höjdaren inom V75 vid sidan av dessa lopp är trekilometersslaget Per Ulvens Minneslopp med 14 hästar utspridda på fem volter. Längst bak finns bland annat svenskfödde, femfaldige miljonären <strong>Bordeaux S.</strong> (e. Orlando Vici), som efter 3,5 år på fransk mark återvände till Skandinavien i våras och då i träning hos Frode Hamre. Nu kan ha ta andra segern i åttonde försöket hos Hamre.</p>



<p class="wp-block-paragraph">Dagens mest intressanta äldre travare är dock förpassade till ramloppen. Där blir det en duell mellan två topptreåringar från samma stall. Det handlar om Geir Vegard Gundersens duo<strong> Devilish Hill</strong> (e. Muscle Hill) och <strong>Charron</strong> (e. Code Bon), som möts i Karsten Buers Minneslopp över medeldistans. Devilish Hill vann spårlottningen – innerspår – och har Charron direkt på utsidan.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2024/08/devilishhillheat-617x333.jpg" alt="" class="wp-image-618586" style="width:544px;height:auto"/><figcaption class="wp-element-caption">Devilish Hill. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/09/14bj.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar på Bjerke.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Nordiskt söndagsfokus på Bjerke, men det blir en hel del trav på svensk mark också. På Hagmyren (första start 12.10) är Stig Jarle och Camilla Röstes fina fyraåringssto <strong>Hög Decibel</strong> (e. Art Kjarvald) tillbaka på banan efter att ha slutat fyra i Derbystoet i Östersund för fem veckor sedan, trots galopp.</p>



<p class="wp-block-paragraph">Till de fyraåriga stonas största lopp i Sverige tog sig Hög Decibel genom att spurta hem försöket på finfint sätt.</p>



<p class="wp-block-paragraph">112.000 kronor inbringade de båda starterna och därmed har det blivit ett kliv uppåt i klasserna när hon idag ställs mot både äldre hästar och hingstar/valacker i en vanlig spårtrappa, där hon tjänat minst av de 13 hästarna.</p>



<p class="wp-block-paragraph">Bland dessa en trio från Jan-Olov Perssons stall:<strong> Eskils Balder</strong> (e. Bork Odin), <strong>Backhammer</strong> (e. Tekno Odin) och <strong>Hulte Sixten</strong> (e. Horgen Tore).</p>



<p class="wp-block-paragraph">Med nio segrar är Jörgen Westholm-tränade <strong>Jobspost</strong> (e. Readly Express) Sveriges segerrikaste häst 2025. Bakom följer en trio på sju segrar och en av dessa är Mikael Svinstedt-tränade <strong>Hibovalle</strong> (e. Järvsöviking). Denne vann i senaste starten enda trekilometersloppet för kallblod. Idag på hemmabanan är distansen också lång, men 500 meter kortare än i senaste starten.</p>



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



<p class="has-drop-cap wp-block-paragraph">5 För första gången sedan 2010 körs det ett tvååringslopp på milebanan i Tingsryd (start 14.00). Åtta ungdomar sluter upp i tvååringsloppet me 30.000 kronor till vinnaren, där 15-faldige miljonären Önas Prince har sin andra startande avkomma. Det handlar om stoet <strong>Ballerina</strong>, som körs av sin tränare Per Nordström.</p>



<figure class="wp-block-image size-sulky-mellan2 is-resized"><img src="https://sulkysport.se/wp-content/uploads/2022/05/onasprinceforsokled-617x333.jpg" alt="" class="wp-image-308767" style="width:417px;height:auto"/><figcaption class="wp-element-caption">Önas Prince och Per Nordström. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">En annan svenskfödd förstakullhingst är Calgary Games, som ställer hoppet till Magnus Fermskog-tränade <strong>Alfasgameofthrones</strong>.</p>



<p class="wp-block-paragraph">Banrekordet för tvååringar i Tingsryd har förstås många år på nacken. Det innehas av <strong>I’m A Billion Face</strong> (e. Viking Kronos), som tillsammans med Johnny Takter travade 1.16,5a/1.609 meter vid seger i debuten i september 2007.</p>



<p class="wp-block-paragraph">Dessutom blir det breddlopp i Skellefteå (första start 11.10), där bland annat hemmaprofilen<strong> Zorro Swing</strong> (e. Quite Easy) dyker upp i ett sjuhästarsfält. </p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2025/09/250914.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till söndagens tävlingar.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">6 Fyra divisioner av Kentucky Championship Series Finals ($400.000) avgörs i Lexington, på The Red Mile idag. Mängder av topphästar finns med i startfälten och i loppet för de treåriga stona jagar Andrew Harris<strong> Yo Tilli</strong>e (e. Tactical Landing) nionde raka segern i år. Stoet har tjänat över 400.000 dollar och är obesegrad efter åtta årsstarter. </p>



<figure class="wp-block-image size-full is-resized"><img src="https://sulkysport.se/wp-content/uploads/2021/09/redmile4.jpg" alt="" class="wp-image-219683" style="width:551px;height:auto"/><figcaption class="wp-element-caption">Red Mile i Lexington står i centrum idag i USA. Foto Jeannie Karlsson/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Christopher Beavers <strong>Endurance</strong> (e. Captain Corey) har dominerat tvååringsloppen för hingstar och valacker i Lexington och ser ut att bli favorit i söndagens final.</p>



<p class="wp-block-paragraph"><strong>Super Chapter</strong> (e. Chapter Seven) är överlägsen meritmässigt i de treåriga hingstarna och valackernas final och Marcus Melanders häst har på papperet en mycket lämplig uppgift framför sig.</p>



<h2 class="wp-block-heading">Startlista Kentucky Championship Series final ($400.000), tvååriga ston</h2>



<p class="wp-block-paragraph">Häst (far) – Körsven</p>



<ol class="wp-block-list">
<li>Jailbird Jog (e. Tactical Landing) – Tim Tetrick</li>



<li>Days Away (e. Muscle Hill) – Jason Bartlett</li>



<li>Carve (e. Captain Corey) – Andrew McCarthy</li>



<li>Country Glide (e. Tactical Landing) – David Miller</li>



<li>Victorianas Secret (e. Tactical Landing) – Scott Zeron</li>



<li>Naked And Famous (e. Six Pack) – Todd McCarthy</li>



<li>Godusa (e. Ready For Moni) – Jimmy Takter</li>



<li>Avenzee (e. Gimpanzee) – Andy Miller</li>



<li>Setyoursightshigh (e. In Range) – Dexter Dunn</li>



<li>Leading Lady (e. Walner) – Yannick Gingras</li>
</ol>



<h2 class="wp-block-heading">Startlista Kentucky Championship Series final ($400.000), tvååriga hingstar och valacker</h2>



<p class="wp-block-paragraph">Häst (far) – Körsven</p>



<ol class="wp-block-list">
<li>Silverstein (e. Chapter Seven) – David Miller</li>



<li>Neighver Punt (e. Bar Hopping) – Dexter Dunn</li>



<li>Yo Billie (e. Tactical Landing) – Verlin Yoder</li>



<li>Endurance (e. Captain Corey) – Andrew McCarthy</li>



<li>Impossible Bi (e. Greenshoe) – Marcus Miller</li>



<li>Lindy Living (e. Walner) – Yannick Gingras</li>



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



<li>It Could Be Worse (e. Captain Corey) – Scott Zeron</li>
</ol>



<h2 class="wp-block-heading">Startlista Kentucky Championship Series final ($400.000), treåriga ston</h2>



<p class="wp-block-paragraph">Häst (far) – Körsven</p>



<ol class="wp-block-list">
<li>Yo Tillie (e. Tactical Landing) – Todd McCarrthy</li>



<li>Spicy Nice (e. Tactical Landing) – Jimmy Takter</li>



<li>Voguish (e. Gimpanzee) – Andrew McCarthy</li>



<li>Torrisi (e. Walner) – Tim Tetrick</li>



<li>R Lady W (e. Walner) – Scott Zeron</li>



<li>Stash Some Cash (e. Walner) – Dexter Dunn</li>



<li>Winnpanzee (e. Gimpanzee) – Yannick Gingras</li>



<li>Aperfect Annie (e. Googoo Gaagaa) – James MacDonald</li>



<li>Grand Reserve (e. Walner) – David Miller</li>
</ol>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/07/yotillie1972025lis-617x346.jpg" alt="" class="wp-image-745563"/><figcaption class="wp-element-caption">Yo Tillie. Foto: Lisa Photo</figcaption></figure>



<h2 class="wp-block-heading">Startlista Kentucky Championship Series final ($400.000), treåriga hingstar och valacker</h2>



<p class="wp-block-paragraph">Häst (far) – Körsven</p>



<ol class="wp-block-list">
<li>Super Chapter (e. Chapter Seven) – Dexter Dunn</li>



<li>Mr Mouton (e. Chapter Seven) – Åke Svanstedt</li>



<li>Go Dog Go (e. Greenshoe) – Todd McCarthy</li>



<li>Galen Erso (e. Green Manalishi) – James MacDonald</li>



<li>Gimpanzee Dancer (e. Gimpanzee) – Andrew McCarthy</li>



<li>Monserrate (e. Chapter Seven) – Yannick Gingras</li>



<li>Te Quiero Lindy (e. Walner) – Andy Miller</li>



<li>Mountcastle (e. Muscle Hill) – Scott Zeron</li>



<li>Vugoo (e. Googoo Gaagaa) – Tim Tetrick</li>



<li>Yo Sheldon (e. Love You) – Verlin Yoder</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">7 <strong>Thierry Duvaldestin</strong> blev lördagens store segerherre när han, tillsammans med sonen Théo tog hem två av tre Criterium (des 3 ans och des 4ans) (€300.000). Treårige <strong>Mack de Blary</strong> (e. Face Time Bourbon) fick segern, inte oförtjänt, efter att Magic Night och Paul-Philippe Ploquin brutit ut väl många spår på upploppet, vilket ledde till störningsmoment. Ready Cash-sonen <strong>Lancier du Goutier</strong> var den andra Grupp 1-vinnaren för Duvaldestin, men framgångarna tog inte slut i och med det. </p>



<p class="wp-block-paragraph">Ytterligare två segrar räknades in på Vincennes. Clément Duvaldestin styrde in <strong>Ideal du Rocher</strong> (e. Clif du Pommereux) i Prix Paris-Turf (€75.000) och fjolårets Sweden Cup-finalist vann på 1.13,5/2.850 meter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/duvaldestins-lycka-allaires-olycka/" target="_blank" rel="noreferrer noopener">– –> Läs mer om vinnarna på Vincennes igår här!</a></p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/duvaldestin-show-pa-vincennes/" target="_blank" rel="noreferrer noopener">&#8230;och här!</a></p>



<p class="wp-block-paragraph">Clément vann dessutom med Falcao de Laurma-valacken <strong>Leonardo Vici</strong> i Prix Citizen Kid (€52.000). Stall Duvaldestin har på de senaste 20 starterna vunnit nio lopp, slutat bland de tre främsta i 14 och har alltså två färska grupp 1-segrar inkluderade i detta.</p>



<p class="wp-block-paragraph">Och Thierry Duvaldestin själv som kusk är ingen bluff. Han körde viserligen stjärnan <strong>Idao de Tillard </strong>till en blygsam sjätteplacering förra veckan, men annars imponerar hans siffror vad beträffar kuskstatistiken. <strong>46 starter</strong> som kusk i år, <strong>26 vinster</strong> och sammanlagt <strong>33 gånger</strong> bland de tre främsta.</p>



<p class="wp-block-paragraph">Skaplig träffprocent både som tränare och kusk.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/09/duvaldestin1-617x411.jpeg" alt="" class="wp-image-767317"/><figcaption class="wp-element-caption">Duvaldestins, Théo till vänster och Thierry till höger om Théo, håller skaplig form för tillfället.
Foto: Gerard Forni</figcaption></figure>

Fokustema
Sju nyheter vid sju
Läs senare
Nya chanser i Norge
Norge, Norge och Norge. Topplopp i Oslo idag igen och vi får se om det går att sno åt sig ytterligare svenska segrar i något av Klasselöpningarna.
Thierry Duvaldestins toppdag.
Gundersens jagar fler segrar och så Lexington på det.
Här är dagens Sju nyheter vid sju.
