
<p class="has-drop-cap wp-block-paragraph">1 Tre gånger har Jan-Olov Persson vunnit Norskt Kallblodsderby. <strong>Järvsöfaks </strong>(e. Trollfaks) tog den historiska första svenska segern 1998, tio år senare var den sonen <strong>Järvsövikings</strong> tur och ytterligare ett decennium längre fram i tiden, 2018, slog Persson-tränade <strong>Tekno Eld </strong>(e. Tekno Odin) till på Bjerke.</p>



<p class="wp-block-paragraph">Två år ”för tidigt” för att hålla tioårsintervallet kan det vara dags igen idag på <strong>Bjerke </strong>(första start 13.25). Robuste <strong>Järvsö Robert </strong>var trea i svenska Derbyt – enda gången han varit sämre än tvåa på 13 starter i karriären – och var duktig tvåa i försöket till norska klassikern.</p>



<p class="wp-block-paragraph">Öystein Tjomsland-tränade fyraåringar vann båda försöken genom <strong>Lannem Pär</strong> (e. Tekno Odin) och <strong>Tangen Nils</strong> (e. Bork Odin) och den norske tränardominanten vill säkert påbörja en ny segerrad i norska Derbyt. Ifjol bröts hans sex år långa segersvit.</p>



<p class="wp-block-paragraph">Än längre var den svit som Robert Skoglund-tränade<strong> Ängsrask </strong>(e. Bork Odin) bröt i svenska Derbyt när Ängsrask tillsammans med Ulf Ohlsson ordnade en efterlängtad blågul triumf. Nu kan det bli repris i Norge och tränare Skoglund andas optimism.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/08/angsrask7-617x333.jpg" alt="" class="wp-image-883708"/><figcaption class="wp-element-caption">Ängsrask. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">– Vi har lättat honom ganska mycket i år från pg-skor till aluminium, men nu är tanken barfota runt om. Att springa barfota över lång distans är ju lättare än att springa med skor.  Vi har även testat ryckhuva den här veckan och det svarade han väldigt bra på, sade Robert Skoglund till ATG Live.</p>



<p class="wp-block-paragraph">I Kriteriet är fem av tolv finalister svensktränade och dessutom vann Jan-Olov Perssons duo <strong>Järvsö Jan</strong> (e. Järvsö Björn) och <strong>Skiffer </strong>(e. Lome Brage) varsitt försök. Då satt tränaren själv i vagnen, men idag är han avstängd och Mats E Djuse och Norges etta genom tiderna Eirik Höitomt tar över.</p>



<h2 class="wp-block-heading">Svensktränade finalister – kallblod</h2>



<p class="wp-block-paragraph"><strong>Derbyt – förstapris 795.627 NOK:</strong></p>



<ul class="wp-block-list">
<li><strong>Ängsrask </strong>(e. Bork Odin) – Robert Skoglund (Ulf Ohlsson kör)</li>



<li><strong>Järvsö Robert </strong>(e. Järvsö Elling) – Jan-Olov Persson (Mats E Djuse kör)</li>



<li><strong>Bato Prinsen</strong> (e. Bork Odin) – Stefan Edin</li>



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



<p class="wp-block-paragraph"><strong>Kriteriet – förstapris 457.522 NOK:</strong></p>



<ul class="wp-block-list">
<li><strong>Järvsö Jan </strong>(e. Järvsö Björn) – Jan-Olov Persson (Eirik Höitomt kör)</li>



<li><strong>Skiffer </strong>(e. Lome Brage) – Jan-Olov Persson (Mats E Djuse kör)</li>



<li><strong>Alf (</strong>e. Tekno Jerven) – Lars-Erik Karlsson</li>



<li><strong>Troll Knut </strong>(e. Art Kjarvald) – Jan Ove Olsen (Ulf Ohlsson kör)</li>



<li><strong>Ängsson</strong> (e. B.W.Modde) – Jan Ove Olsen</li>
</ul>



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



<p class="has-drop-cap wp-block-paragraph">2 2024 tog Geir Vegard Gundersen sin tionde seger i Norskt Travderby som kusk och/eller tränare när han själv körde <strong>Charron</strong> (e. Code Bon) till vinst. Därmed klev han upp i samma antal norska Derbyvinster som idolen och stora förebilden Gunnar Eggen.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/geirvegardgundersen2-617x333.jpg" alt="" class="wp-image-604193"/><figcaption class="wp-element-caption">Geir Vegard Gundersen. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Förra året lovade han att lämna in tränarlicensen och låta sonen Magnus ta över rörelsen om han vann norska Derbyt för varmblod. Någon vinst blev det inte för Gundersen som tränare bakom <strong>Nadal B.R. </strong>(e. Googoo Gaagaa).</p>



<p class="wp-block-paragraph">I år har norrmannen två chanser i Derbyt. Magnus kör segermaskinen <strong>Kaprizov</strong> (e. Maharajah), medan ”GV” själv sitter upp bakom <strong>Onyx B.R. </strong>(e. Maharajah). Och löftet från förra året står fast:</p>



<p class="wp-block-paragraph">– Ja, då blir Magnus tränare, säger Geir Vegard till Trav- og Galopp-Nytt.</p>



<p class="wp-block-paragraph">Två svenska tränare har vunnit norska Derbyt för varmblod. Björn Linder tränade 1997 års vinnare <strong>News From Heaven </strong>(e. Super News) och Björn Goop satt bakom egentränade <strong>Muscles Wiking B.R. </strong>(e. Muscles Yankee) 2011.</p>



<p class="wp-block-paragraph">I år finns två svensktränade hästar bakom bilen. Mifsud Tyler kvalade in Joakim Lövgren-tränade  <strong>emstone Aze</strong> (e. Traders), medan Paw Mahony tog finalplats med <strong>Maserati Salt </strong>(e. Maharajah).</p>



<p class="wp-block-paragraph">– Vi ligger lågt, samtidigt som ett Derby är allt eller inget. Det kommer att hända saker, det såg vi ju senast i svenska Derbyt. En jätteoutsider kan vi kalla honom, säger Lövgren i Lövgrens Webb-TV.</p>



<p class="wp-block-paragraph">I Kriteriet saknas svensktränade hästar och loppet har drabbats av ett stort frånfall när förhandsfavoriten <strong>A Perfect Match</strong> (e. Lionel) fått strykas sedan han gjort sig illa i boxen.</p>



<h2 class="wp-block-heading">Svensktränade finalister – varmblod</h2>



<p class="wp-block-paragraph"><strong>Derbyt – förstapris 779.787 NOK:</strong></p>



<ul class="wp-block-list">
<li><strong>Gemstone Aze </strong>(e. Traders) – Joakim Lövgren</li>



<li><strong>Maserati Salt </strong>(e. Maharajah) – Paw Mahony</li>
</ul>



<p class="wp-block-paragraph">Vid sidan om Derbyt plockar Joakim Lövgren ut <strong>Natorp Bo</strong> (e. Andover Hall) i högsta klassen, Karsten Buers Minneslopp med 125.000 kronor i förstapris. Någon tur i spårlottningen hade inte Natorp Bo, som inleder från spår åtta. </p>



<p class="wp-block-paragraph">Bland motståndarna finns Srf Stable-ägda duon <strong>Crown</strong> (e. Chapter Seven) och <strong>Rome Pays Off </strong>(e. Muscle Hill). Båda hästarna tränas av Frode Hamre. Favorit blir dubble Elitloppsdeltagaren och forne norske Derbyvinnaren <strong>Charron</strong> (e. Code Bon).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/13v85.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/09/13v85.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">3 På svensk mark tävlas det på tre banor och först ut är vår enda milebana <strong>Tingsryd </strong>(första start 11.00). Starttiden till trots handlar det inte om breddlopp utan vanliga prispengar med 30.000 och 40.000 kronor i förstapris.</p>



<p class="wp-block-paragraph">Dessutom är det säsongsfinal och championtitlarna ska delas ut. Det kan bli en rafflande kamp om kuskchampionatet, men det står klart att det bli en vinnare som aldrig varit banchampion i Sverige tidigare. </p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/juliancordeau-617x333.jpg" alt="" class="wp-image-893854"/><figcaption class="wp-element-caption">Julian Cordeau. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="wp-block-paragraph">Julian Cordeau – 23 st: 5-4-5 – har greppet inför årsfinalen och kör fyra hästar. Tvåan Stefan Persson och trean Johan Untersteiner står över, men på plats fyra finns Tyler Mifsud – 13 st: 3-2-0. Tyler Midsud kör sex hästar, varav fem åt arbetsgivaren Joakim Lövgren, och behöver minst en trippel för att kliva förbi Julian Cordeau.</p>



<p class="wp-block-paragraph">Markus Waldmüller har också en minimal chans att komma ikapp ledaren, men då krävs det seger med samtliga tre styrningar idag samtidigt som Cordeau kör blankt.</p>



<p class="wp-block-paragraph">Högervarvstävlandet fortsätter i <strong>Åmål </strong>(första start 14.00), där Christoffer Eriksson-tränade <strong>Cross Lane </strong>(e. Nuncio) är tävlingsdagens mest meriterade häst. Han har gjort tre starter (1-1-0) i sommar efter elva månaders uppehåll och får Victor Rosleff i sulkyn.</p>



<p class="wp-block-paragraph">Söndagen kompletteras med breddlopp i <strong>Boden</strong> (första start 11.10).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/260913.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/09/260913.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar i Sverige.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">4 Jörgen Sjunnesson köpte tvååriga stoet <strong>Freya </strong>(e. Chapter Seven-Unexpected Gift), 1.17,0/$7.295, på nätauktionen Ongait och betalade 15.200 dollar.</p>



<p class="wp-block-paragraph">Fem starter (0-3-1) har stoet gjort i regi Dylan Huckabone-Miller och i sin senaste start slutade hon fyra i ett försök i Excelsior Series på Batavia Downs.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/te0fba9f8a98e4bbc9671bca4a16b2ae5fullsizerender4fd2185a421a42a08dd1aab67185e349-617x516.jpeg" alt="" class="wp-image-897331"/><figcaption class="wp-element-caption">Freya. Foto: privat</figcaption></figure>



<p class="wp-block-paragraph">Det är andra gången hon säljs på auktion. Ifjol klubbades hon för 70.000 dollar på Lexington Selected Yearling Sale. Modern <strong>Unexpeted Gift</strong> (e. Cantab Hall), 1.14,2/$1.728, är undan New Jersey Sire Stakes-vinnaren och Merrie Annabelle-trean <strong>Southwind Catlin</strong> (e. Muscles Yankee), 1.12,5/$204.734.</p>



<p class="wp-block-paragraph">Hon är också mor till <strong>Spider Blue Chip </strong>(e. Andover Hall), 1.09,3*/$1.264.522, <strong>Berkery J </strong>($286.325), <strong>Mandela Blue Chip</strong> ($190.777), <strong>Another Chapter</strong> ($161.594), <strong>Union Forces</strong> ($157.365) och <strong>Tantra Blue Chip</strong> ($137.708).</p>



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



<p class="has-drop-cap wp-block-paragraph">5 Sin tredje raka Breeders Crown-triumf (€40.020) tog <strong>Zoom Diamant </strong>(e. Maharajah-Keystone Tabby) för äldre hästar när han hittade fritt spelrum och hann ifatt Uccellone (e. Corleone) kort före mål i Berlin igår. Jim Weldman och Zoom Diamant inledde i femte inner, vilket blev tredje invändigt ut på sista bortre långsidan innan luckan kom på upploppet. Vinnartiden skrevs till 1.11,4a/1.900 meter.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/09/skarmavbild20260912kl.20.49.10-617x342.jpg" alt="" class="wp-image-897414"/><figcaption class="wp-element-caption">Zoom Diamant (mitten) var starkast sista biten. </figcaption></figure>



<p class="wp-block-paragraph">Zoom Diamant har en stark karriär och har tidigare bland annat vunnit Kriterium der Dreijährigen, Adbell-Toddington-Rennen, Buddenbrock-Rennen, Bild-Pokal, Charlie Mills Memorial och Super Trot Cup.</p>



<p class="wp-block-paragraph">Modern <strong>Keystone Tabby </strong>(e. Classic Photo), 1.11,5/€53.540, har också lämnat Timberlake Diamant (e. Muscle Hill), 1.12,9/€45.330.</p>



<p class="wp-block-paragraph"><strong>Sahara Firebird</strong> (e. Googoo Gaagaa-Votum Deo) finalvann Tyskt Breeders Crown (€35.018) för äldre ston och var överlägsen från spets för Robbin Bot på 1.13,3a/1.900 meter. Det var hennes andra BC-seger i Tyskland och bland meriterna finns också triumfer i Auktions-Rennen och Adbell-Toddington-Rennen.</p>



<p class="wp-block-paragraph">Stoet såldes på den tyska Derbyauktionen som ettåring för 14.000 euro. Hon är undan ostartade <strong>Votum Deo</strong> (e. Like A Prayer), vilken har sin främsta avkomma i Vegas Deo (e. Cantab Hall), 1.13,0/$58.060.</p>



<p class="wp-block-paragraph">Votum Deo är i sin tur helsyster med <strong>Godiva Hall</strong>, 1.09,9/$818.475, och i samma syskongrupp ingår också <strong>Highland Mowgli </strong>(e. Archangel), 1.10,1/$391.907, och <strong>Golden Genes Hall </strong>(e. Striking Sahbra), 1.13,0/$125.059.</p>



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



<p class="has-drop-cap wp-block-paragraph">6 Igår tävlade de äldre hästarna i Tyskt Breeders Crown – se ovan! – och idag är det två-,tre och fyraåringarna som tävlar på Mariendorf-banan i Berlin.</p>



<p class="wp-block-paragraph">Mats Strandqvist har fyra debutanter till start i Breeders Crown (€17.713) för tvååringar och anlitar Jörgen Sjunnesson bakom två av hästarna. I hingstarna och valackernas uppgörelse sitter han upp bakom debutanten <strong>Summermusic’vibes S</strong> (e. Captain Corey), medan Marciano Hauber tar hand om <strong>Cashback S </strong>(e. Ecurie D.).</p>



<p class="wp-block-paragraph">I stonas lopp sitter Sjunnesson upp bakom <strong>Nightwish S</strong> (e. Credit Winner) och Strandqvists andra vapen <strong>Stereo Love S</strong> (e. Bar Hopping) körs av Jochen Holzschuh.</p>



<p class="wp-block-paragraph">Till Berlin åker också Johan Untersteiner för att köra egentränade <strong>Gauthier </strong>(e. Maharajah) i Breeders Crown (€27.225) för treåriga hingstar och valacker.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/09/berlin1392026.pdf" target="_blank" rel="noreferrer noopener">Startlistorna till tävlingarna på Mariendorf hittar ni här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Det bjöds på storloppet i Avenches i Schweiz igår – Prix du President – och skrällvann till drygt 24 gånger pengarna gjorde tioårige <strong>Gold du Rabutin</strong> (e. Prince d’Espace-Taormina du River) och Quentin Chauve-Laffay före Fire Cracker och Idem du Pont på 1.13,3a/2.350 meter. Förstapriset uppgick till 12.824 schweiziska franc.</p>



<p class="wp-block-paragraph">Det var första segern i år och ifjol gick Loris Ferros häst också segerlös, medan det blev två triumfer under 2024. </p>
