
<p class="has-drop-cap">1Solvalla (första start 18.15) och Jägersro (start 18.27) delar på uppmärksamheten denna onsdag kväll och på  huvudstadsbanan dyker sex obesegrade travare upp, varav en inom V86.</p>



<p><strong>Global Midnight </strong>(e. Ganymede) hade en fin tävlingskarriär hos Åke Svanstedt, Peter Arnqvist och avslutningsvis Vincent Martens och travade banrekord när hon vann på 1.09,9a/1.609 meter i Tingsryd 2012. I avelsboxen har det gått tyngre för den nästan fyrfaldiga miljonärskan, men kanske är det på väg att lossna.</p>



<p>På Solvalla ikväll (första start 18.15) plockar Conrad Lugauer ut dottern <strong>Global</strong> <strong>Enterprise</strong> (e. Ready Cash), som är obesegrad efter två starter. Nu ställs hon mot flera segervana travare i ett stolopp i jakten på att förlänga segersviten i spårtrappan, där fältets näst rikaste häst – och värsta konkurrenten – Mattias Djuse-tränade <strong>Nephtys Boko</strong> (e. Trixton) inleder från spår åtta. En annan utmanare är Björn Goops Henessi Bourbon (e. Face Time Bourbon), som inlett med två segrar på fyra starter.</p>



<p>Övriga hästar som inte vet hur det känns att förlora då? I nolloppet startar kvartetten <strong>Kon Tiki Mearas </strong>(e. S.J.’s Caviar), <strong>Mastroianni</strong> (e. Twister Bi), <strong>Ringo la Roque</strong> (e. Ringostarr Treb) och <strong>Berghsäker W.F.</strong> (e. Readly Express) med varsin seger i bagaget, medan Daniel Wäjersten reser söderut med <strong>Patriot Zon</strong> (e. Maharajah) som vunnit sina två första starter.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/01/24v86.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till kvällens tävlingar.</a></p>



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



<p class="has-drop-cap">2Adrian Kolgjini avslutade 2023 starkt med tolv av stallets totalt 74 segrar i december. Det nya året har fortsatt i segerstim. Fem segrar på 13 starter har det blivit så här långt för Kolgjini, som på hemmabanan plockar ut fem hästar ikväll.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/06/natkingcole-617x333.jpg" alt="" class="wp-image-318842"/><figcaption class="wp-element-caption">Nat King Cole tillsammans med Adrian Kolgjini. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Bland annat startar <strong>Nat King Cole </strong>(e. Mucle Hill), som lovande en hel del som treåring 2022, men fick större delen av fjolårssäsongen förstörd. Istället har han kommit tillbaka i vinter och har en enkel spetsseger i senaste starten i ryggen inför onsdagens uppgift. Dock handikappas Nat King Cole av utgångsläget – spår åtta delades ut i spårlottningen.</p>



<p>Det väntar jackpot på V86 med över 9,6 miljoner kronor extra i åttarättspotten i omgången som delas mellan Solvalla och Jägersro.</p>



<p>Sulkysports spelstuga inför V86 med viktiga punkter, spikar, drag och favoriter i fara publiceras klockan 12.00.</p>



<p><em>Vill du spela V86 tillsammans med Sulkysport kan du välja mellan följande alternativ:</em></p>



<p><a href="https://www.atg.se/andelskungen/spel/251721_V86_2024-01-24_40_1" class="">Sulkysport Lilla V86 – 15 andelar á 95 kr/styck</a></p>



<p><a href="https://www.atg.se/andelskungen/spel/206235_V86_2024-01-24_40_1" class="">Sulkysport Stora V86 – 15 andelar á 250 kr/styck</a></p>



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



<p class="has-drop-cap">3Efter att vunnit lopp som treåring på Solvalla gick karriären i stå för <strong>Charles du Sud</strong> (e. Fast Photo) 1.13,4am/426.200 kr.</p>



<p>Efter att tränats av Maxime Marais karriären igenom prövar åttaåringen nu lyckan hos Oskar J Andersson efter att Spante Trav AB och Cristalit AB valt att leasa valacken.</p>



<p>Två försök i STL-sammanhang har gjorts med en tredjeplats i ett Klass II-försök och en femteplats i efterföljande final som resultat.</p>



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



<p class="has-drop-cap">4Gott om blågula hopp är det ont om på fransk mark denna onsdag. Jarmo Niskanen är ensam svensk om att ha starthäst i Frankrike och då handlar det om Sverigebekante <strong>Dexter Chatho </strong>(e. Un Amour d&#8217;Haufor) som nu är tillbaka i födelselandet efter en sejour hos Håkan B och Gustav Johansson.</p>



<p>Elvaåringen kommer till start i Prix Une de Mai (€58.000) i Cagnes-sur-Mer (första start kl. 14.00) där segerchecken uppgår till 26.100 euro och hästen finns alltjämt i Stall Dexter Chathos ägo.</p>



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



<p class="has-drop-cap">5Från USA till Danmark och nu åter till USA. Den resan gör Cantab Hall-brodern <strong>Coventry Hall </strong>(e. Cash Hall) 1.09,9ak/1.077.089 ddk efter att kört fast på dansk mark och blott gjort fyra starter under fjolåret.</p>



<p>Två av dem resulterade i seger och därtill vann hästen Sprintermästaren i Billund för tre år sedan, men i övrigt har det varit sparsamt med framgångar på nordisk mark för den toppstammade hästen.<br>– Jag har ju sett den succé som Per Engblom har haft med flera danska hästar; ja i det stora hela har han ju haft fantastiska framgångar i USA. Hans hästar vinner lpp hela tiden, <a href="https://travservice.dk/coventry-hall-skal-i-traening-i-usa/" target="_blank" rel="noreferrer noopener">förklarar Keld Gregersen hos Stall Disney valet av hästens nya tränare.</a></p>



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



<p class="has-drop-cap">6 Dubble världsrekordhållaren <a rel="noreferrer noopener" href="https://sulkysport.se/ecurie-d-till-avel/" data-type="link" data-id="https://sulkysport.se/ecurie-d-till-avel/" target="_blank">Ecurie D.</a> (e. Inifinitif-To Soon), 1.07,9*/$1.516.807, har blivit far för första gången. På Crawford Farms i USA har toppstoet <strong>Barn Girl </strong>(e. Cash Hall-Turquoise Sweetie), 1.09,3/$860.478, blivit mor till en hingst efter Åke Svanstedts storstjärna.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2022/10/race8ecuried4-617x367.jpg" alt="" class="wp-image-374418"/><figcaption class="wp-element-caption">Ecurie D. och Dexter Dunn vinner finalen i Breeders Crown. Foto Gerard Forni</figcaption></figure>



<p>Under sitt första år i aveln betäckte danskfödde Ecurie D. 81 ston på andra sidan Atlanten – i Sverige lyckliggjordes 39 på fryst sperma.</p>



<p>Modern Barn Girl vann 66 av 132 starter innan hon gick till avel. Hennes förstfödda såg dagens ljus 2021 och efter tre raka ston efter Chapter Seven, Walner och Chapter Seven blev det en hingst. Äger gör Crawford Farms i Syracuse i staten New York.</p>



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



<p class="has-drop-cap">7Efter en fjärdeplats i sommarens korta Breeders Course-final och en andraplats i Breeders Crown-uttagning så gör idag <strong>Ni Hao Bros </strong>(e. Nuncio) debut i Alessandro Gocciadoros regi.</p>



<p>Det svenskfödda, fyraåriga stoet kommer till start i Gran Premio Scuderia Bruni Sara e Scuderia Osti Leila (€11.550) i Milano och det sker bland annat i konkurrens med den inhemska årgångstoppen <strong>Elleboro Dr</strong> (e. Oasis Bi).</p>



<p><strong>Startlista</strong><br><em>1.650 meter autostart</em></p>



<ol class="wp-block-list">
<li>Ni Hao Bros (e. Nuncio) – Alessandro Gocciadoro</li>



<li>Ethan (e. Nad Al Sheba) – Simone Levacovich</li>



<li>Excelsior (e. Wishing Stone) – Lorenzo Baldi</li>



<li>Eridamia (e. Adrian Chip) – Marco Stefani</li>



<li>Eraldo Jet (e. Donato Hanover) – Andrea Guzzinati</li>



<li>Eclisse Roc (e. Iper Roc) – Filippo Rocco</li>



<li>Elleboro Dr (e. Oasis Bi) – Pietro Gubellini</li>



<li>Ebano degli Dei (e. Mago d&#8217;Amore) – Andrea Farolfi</li>
</ol>

Fokustema
Morgonsvepet
Läs senare
Lyckligt ovetande!
Om kvällens sex starthästar som alltjämt är obesegrade, guldvinnaren som är tillbaka i Frankrike och Breeders Course-fyran som gör debut på italiensk mark går bland annat att läsa i dagens morgonsvep.
