
<p class="has-drop-cap wp-block-paragraph">1Sex raka Derbysegrar i Sverige, fyra raka i Norge. Den senaste som kunnat stoppa Öystein Tjomslands enorma dominansen i de kallblodiga fyraåringarnas klassiker är Jan-Olov Persson. 2017 vann <strong>Järvsö Pegasus</strong> (e. Tangen Scott) i Östersund och 2018 segrade <strong>Tekno Eld</strong> (e. Tekno Odin) på Bjerke. Sedan dess har det varit Tjomsland, Tjomsland, Tjomsland…<br>Idag på <strong>Bjerke</strong> (första start 13.00) fortsätter den norska klasselöpshelgen med finalerna för hingstar och valacker i Kriteriet och Derbyt för både varm- och kallblod.</p>



<p class="wp-block-paragraph">Det blir svenskt deltagande i tre av fyra finaler och den store dominanten är Jan-Olov Persson med sex av tolv hästar i kallblodens Derbyfält! Det handlar om <strong>Envis, Juni Blixt, Brolin, Björs Balder, Blomsterprinsen</strong> och <strong>Prinsen af Sola</strong>, men en viss Tjomsland sitter med trumf på hand igen. Hans svenske Derbyvinnare <strong>Bore Mikkel</strong> är nämligen inte ens stallets bästa segerchans. Den positionen tar <strong>Brenne Borken</strong>, som är obesegrad efter nio starter.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/kan-tanka-mig-ledningen/" target="_blank" rel="noreferrer noopener">Här är Mats E Djuses funderingar inför kallblodsderbyt på Bjerke.</a></p>



<p class="wp-block-paragraph">På varmblodssidan blir det också svensktränat genom Jägersrotränaren Preben Sövik och hans vinnare av Jarlsberg Grand Prix: <strong>Just Perfect Sisu</strong>.</p>



<p class="wp-block-paragraph"><strong>Övriga svenska hästar i de klassiska finalerna:</strong><br><strong>Kriteriet (450.000 kr): </strong>Guldhagens Pirat (Carl-Gustav Andersson), Friska Viljan (Oskar Kylin Blom), Ellbert (Anders Hafstad)<br><strong>Derbyt (700.000 kr): </strong>Holms Pegasus (Alf Nordh)</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/09/10v75bj.pdf">Här kan du ta del av dagens startlistor till tävlingarna på Bjerke.</a></p>



<p class="wp-block-paragraph">Det är V75-spel från Sverige till dagens tävlingar på Bjerke och i ett av de ”vanliga” loppen plockar Robert Bergh ut <strong>Power</strong> (e. Googoo Gaagaa), som ställs mot <strong>Stoletheshow</strong> (e. Dream Vacation) och <strong>Best Ofdream Trio</strong> (e. Nad Al Sheba) i Karsten Buers Äreslopp för äldre varmblodseliten.</p>



<p class="wp-block-paragraph">Här är spelstugan med viktiga punkter, spikar och favoriter i fara på V75 idag!</p>



<p class="wp-block-paragraph"><em>Vill du spela V86 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-09-10_78_5">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/05/m.t.insider1-617x333.jpg" alt="" class="wp-image-308316"/><figcaption class="wp-element-caption">M.T.Insider och Olle Alsén. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">2Speedrace över 164 meter i centralt belägna Boulognerskogen i Gävle. Det är publikdragaren på svensk travmark idag under rubriken ”Hästen till folket” från klockan 12.00 idag.<br>Sex varmblod är indelade i två grupper, där alla hästar möter varandra en gång. Sedan sammanställs två tabeller, där ettorna i de båda grupperna möter tvåorna från den andra gruppen. Sedan möts vinnarna i final. Totalt blir det fyra 164-metersheat för de hästar som går hela vägen.</p>



<p class="wp-block-paragraph">Bland de sex deltagarna finns 13-årige speedrace-profilen<strong> M.T.Insider</strong> (e. Offshore Dream), som gör ”minicomeback” efter att ha varit borta från tävlingsbanan sedan Elitloppshelgen 2022.</p>



<ul class="wp-block-list">
<li><strong>Deltagare, grupp 1:</strong> M.T.Insider (Olle Alsén), Enge Eros (Jimmy Dahlman), Kaj di Quattro (Felicia Molin).</li>



<li><strong>Grupp 2:</strong> In Line Tooma (Fredrik Wallin), Maison Plage (Erika Åsblom), Antante T.M. (Rikard N Skoglund)</li>
</ul>



<p class="wp-block-paragraph">När det gäller tototävlingar på svensk mark är utbudet breddlopp på tre banor: Hagmyren (start 11.00), Solvalla (start 11.10) och Vaggeryd (start 14.00).</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/09/230910.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">3 Sedan 2007 har Momarken arrangerat Unionskampen, men nästa år år det slut med det. Då flyttas tävlingarna till Bjerke. Trav-og Galopp-Nytt skriver att det sker efter påtryckningar från spelbolaget ATG…</p>



<p class="wp-block-paragraph">Momarken hade problem med banan i år och nu ställer ATG krav på säkerheten runt arrangemanget, skriver <a href="https://tgn.no/artikkel/vi-flytter-stevnet-for-a-vaere-sikker-pa-at-vi-kan-levere-produktet/" target="_blank" rel="noreferrer noopener">tgn.no</a>.</p>



<p class="wp-block-paragraph">– Vi på DNT har inte fått någon förfrågan, men via Rikstoto har ATG informerat oss om att om Unionskampen ska finnas med på schemat 2024 så måste det säkerställas att V75-tävlingen kan uppfylla de svenska kraven. Därför har vi valt att flytta Unionskampen till Bjerke för 2024, säger DNT:s generalsekreterare Svein Morten Buer till tgn.no.</p>



<p class="wp-block-paragraph">Unionskampen är planerad till den 16 mars nästa år, men då på Bjerke och inte Momarken.</p>



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



<p class="has-drop-cap wp-block-paragraph">4 Nancy Takters Hambletonian-vinnare <strong>Tactical Approach</strong> (e. Tactical Landing) åkte på stryk i senaste starten mot <strong>French Wine</strong>. Ikväll svensk tid är treåringen tillbaka på Red Mile för att gå ut i ett försök i Kentucky Sires Stake Championship Series ($80.000). Nu slipper han möta French Wine, men motstånd saknas inte.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/08/tacticalapproachszh230729adamstromstalltz-617x442.jpg" alt="" class="wp-image-478234"/><figcaption class="wp-element-caption">Tactical Approach. Foto: Adam Ström/stalltz.se</figcaption></figure>



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



<p class="wp-block-paragraph"><strong>Kentucky Sires Stake Championship Series</strong> ($80.000)<br>Treåriga hingstar/valacker, försök.<br><em>1.609 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven/tränare</strong></p>



<ol class="wp-block-list">
<li><strong>Ari Ferrari J</strong> (e. Walner) – Dexter Dunn/Tony Alagna</li>



<li><strong>Kilmister </strong>(e. Chapter Seven) – Brian Sears/Marcus Melander</li>



<li><strong>Khaosan Road</strong> (e. International Moni) – Tim Tetrick/Åke Svanstedt</li>



<li><strong>Buckhead Ridge</strong> (e. Nuncio) – David Miller/Gregg McNair</li>



<li><strong>Brodeur </strong>(e. Tactical Landing) – Tony Hall/Anette Lorentzon</li>



<li><strong>Point of Perfect </strong>(e. Walner) – Yannick Gingras/Ron Burke</li>



<li><strong>Tactical Approach</strong> (e. Tactical Landing) – Scott Zeron/Nancy Takter</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">5 Säsongsfinal är det idag i österrikiska Baden och där bjuds det på den 31:a upplagan av Grosser Badener Zukunfts-Preis (€5.000) för tvååringar över distansen 1.600 meter och samtliga sex travare gör tävlingsdebut.</p>



<p class="wp-block-paragraph">Snabbaste kvaltiden står stoet <strong>Face Time Spada (</strong>e. Face Time Bourbon-Spada Nera) för och hon noterade 1.18,6a/1.600 meter i Baden den 10 augusti. Gerhard Mayr sitter i sulkyn i loppet där vinnaren hämtar 2.500 euro.</p>



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



<p class="wp-block-paragraph"><strong>Grosser Badener Zukunfts-Preis </strong>(€5.000)<br>Tvååringar.<br><em>1.600 meter, autostart.</em></p>



<p class="wp-block-paragraph"><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Another Star</strong> (e. Light Kronos) – Hubert Brandstätter</li>



<li><strong>Face Time Spada</strong> (e. Face Time Bourbon) – Gerhard Mayr</li>



<li><strong>Velvet Venus</strong> (e. Light Kronos) – Christop Fischer</li>



<li><strong>Super Crown </strong>(e. Dijon) – Kurt Sokol</li>



<li><strong>Power Rocket Girl </strong>(e. Muscle Hill) – Cornelia Mayr</li>



<li><strong>Au Revoir </strong>(e. Shaman Hall) – Martin Floh</li>
</ol>



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



<p class="has-drop-cap wp-block-paragraph">6 Hingsten <strong>Callela Alabtross</strong> (e. Love You-Arctic Elsa) blev dyrast på finska ettåringsauktionen Varsahuutokauppa i fredags i Ypäjä och en anonym köpare betalade 35.000 euro. Modern <strong>Arctic Elsa</strong> (e. Express It), 1.13,0a/€94.885, vann Finskt Breeders Crown och hon har sin första avkomma i Callela Albatross.</p>



<p class="wp-block-paragraph">Näst dyrast var hingsten <strong>Hatrick Match</strong> (e. Father Patrick-Song Chapter) för 27.000 euro och även hans amerikanska mor <strong>Song Chapter </strong>(e. Chapter Seven), 1.12,4/$130.011, hade också sin första avkomma ute till försäljning.</p>



<p class="wp-block-paragraph">Bland de utbjudna fanns även en halvbror till Derbyvinnaren <strong>Crepe Match</strong> (e. Creatine) vid namn <strong>Stonecapes Yoda</strong> (e. Southwind Frank), men han ropades tillbaka för 24.000 euro. Han såldes – enligt Hevosurheilu – efter auktionen.</p>



<p class="wp-block-paragraph"><a href="https://www.hevoshuutokaupat.fi/info/tulokset/tulokset-2023/" target="_blank" rel="noreferrer noopener">Här hittar ni samtliga resultat från auktionen.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">7 Tomas Malmqvist tävlar flitigt med tvååringar i Frankrike. Idag jagar <strong>Lorica </strong>(e. Booster Winner) karriärens första seger i Prix Bellino II (€13.500) i <strong>Chateaubriant </strong>(första start kl. 14.30) efter att inlett med en tredjeplats i Cabourg för två veckor sedan.</p>



<p class="wp-block-paragraph">På samma bana startar Yannick Henrys svenskfödde sjuåring <strong>Gardner Shaw</strong> (e. Ready Cash) i Grand Prix de Chateaubriant (€25.000) och valacken jagar sin fjärde årsseger.</p>



<p class="wp-block-paragraph">I EU-loppet Prix Traiteur La Marigotiere (€24.000) i <strong>Bernay</strong> (första start kl 13.00) prövar Jörgen Westholm lyckan med såväl<strong> Ara </strong>(e. Maharajah) som <strong>Made of Stars</strong> (e. Super Photo Kosmos) och i samma lopp syns Stefan Arvidssons <strong>G.K.Justus </strong>(e. Brad de Veluwe) och Ron Kuipers <strong>General du Nord</strong> (e. Un Mec d’Heripre).</p>



<p class="wp-block-paragraph">Marie Norberg beger sig till samma bana för att starta treårige<strong> Kool Viking </strong>(e. Let’s Go Along) i Prix du PMU La Tabatiere Thiber (€15.000), Ron Kuiper prövar med <strong>Hit Money</strong> (e. Cristal Money) i Prix Abaca Pelin Ciel (€5.500) och så har Tomas Malmqvist <strong>Junior du Vallon </strong>(e. Coktail Jet) i Prix de l’Ibtn (€15.000).</p>



<p class="wp-block-paragraph">Tvååringsstart handlar det även om för Henrik Hollstens <strong>Lady Oh </strong>(e. Follow You) och <strong>Love Your Song</strong> (e. Goetmals Wood) då de kommer ut i inledningsloppet Prix de la Maison de Retraite St Aubin (€11.500).</p>



<p class="wp-block-paragraph">Hollsten debuterar även tvååriga stoet <strong>Lovely Lisa</strong> (e. Fabulous Wood) i Prix La Pacha (€10.000) i <strong>Moulins-La-Marche</strong> (€10.000) dit även Jarmo Niskanen sänder <strong>Impactdarche </strong>(e. Quaker Jet) för start i Prix Le Jardinier d’Argenteuil (€14.000).</p>



<p class="wp-block-paragraph">I <strong>Nimes</strong> (första start 15.00) startar två svenskfödda hästar i Prix de l’Olivado-Business Club Nimois (€24.000). Michael Daougabels <strong>Testa di Cavolo</strong> (e. Un Mec d’Heripre) ska försöka hålla undan 25 meter för David Ciniers<strong> Dante Godiva</strong> (e. Up And Quick) i strid om segerchecken på 10.800 euro.</p>
