
<p class="has-drop-cap">1 Kallblodens väg till Derbyt i Östersund i sommar börjar ikväll. Då drar nämligen vintern och vårens löpningsserie Sleipner Cup för fyraåringar igång. Efter 13 försök med olika propositioner till och med 2 maj väntar finalerna för hingstar/valacker respektive ston på Romme den 19 maj med 150.000 kronor i förstapris.</p>



<p>Förra året vann Jerker Bjurman-tränade <strong>Mira Kiro </strong>(e. Bork Odin) stofinalen, medan Anders Lundström Woldens <strong>Reime Blesen</strong> (e. Mörtvedt Jerkeld) vann klassen för hingstar och valacker.</p>



<p>Nio fyraåringar sluter upp i årets första försök i Bollnäs och det är stor dominans från Jan-Olov Persson. Hela fem av de nio hästarna kommer från hans stall. Bland dessa funns <strong>Björs Balder</strong> (e. Smedheim Solan), som gör sin första start sedan  han slutade fyra i Svenskt Kallblodskriterium på Dannero i augusti.</p>



<p><strong><em>Här körs försöken till Sleipner Cup: </em></strong>Bollnäs (2 feb), Gävle (19 feb), Bergsåker (15 mars), Umåker (23 mars), Romme (24 mars), Dannero (8 april), Bergsåker (11 april), Gävle (18 april), Bollnäs (20 april), Östersund (24 april), Hagmyren (1 maj), Skellefteå (2 maj), Rättvik (5 maj).</p>



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



<p class="has-drop-cap">2 Bollnäs (första start 18.20) är fredagens huvudbana med kvällstävlingar och förutom Sleipner Cup-försöket bjuds bland annat ett försök i dubbelcupen som håller god klass. Bland annat gör Jessica Sidbäcks <strong>Farmpilot</strong> (e. Farmbaron) årsdebut efter sex segrar på nio starter förra året och ställs mot Hanna Forslins kapable men ack så osäkre <strong>Sol Storm </strong>(e. Smedheim Solan) på startfållan.</p>



<p>Joakim Reiser är nybliven proffstränare och redan i andra starten med A-licens kom första segern när han på Solvalla reglerade allt från dödens med <strong>Klack Pansar</strong> (e. Klack Jo). Denne jagar nu 20 meter bakom Sidbäcks och Forslins hästar.</p>



<p>På varmblodssidan gör en annan segerstaplare årsdebut. Jimmy H Anderssons toppstammade femåring <strong>In Love Mearas</strong> (e. Cantab Hall) vann fem av sju lopp förra året.</p>



<p>På fredagens lunchbana Örebro (start 12.20) låter Oskar J Andersson fyraårige Sultan Sea (e. Maharajah) testa lång distans för första gången. Hästen har inlett lovande med tre segrar på åtta starter och fungerat bra i vinter.</p>



<p><a rel="noreferrer noopener" href="https://sulkysport.se/wp-content/uploads/2023/01/230203.pdf" target="_blank">Här är startlistorna till fredagens tävlingar.</a></p>



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



<p class="has-drop-cap">3 Idag avgörs den australiensiska storloppet Great Southern Star på Tabcorp Melton Park-banan.<br>Loppet körs med försök och final och har en samlad prissumma på 400.000 australiska dollar varav 300.000 av dem utgör prispotten i finalen.</p>



<p>Förutsättningarna är 1.720 meter autostart och de fem främsta från de två försöksloppen tar sig vidare till finalen.<br>Årets sto 2022 <strong>Queen Elida </strong>(e. Love You) finns med i det första försöksloppet och Årets häst 2022 <strong>Majestuoso</strong> (e. Majestic Son) syns i det andra heatet vilken även vann fjolårets upplaga av Great Southern Star.</p>



<p>ATG arrangerar spel och sänder tävlingarna vars försökslopp avgörs 09.03 samt 09.33 innan final brakar loss 12.05.</p>



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



<p class="has-drop-cap">4 Cato Antonsen, som fyller 64 år i år, är ett aktat namn inom norsk travsport och Momarkentränaren närmar sig ett litet jubileum som kusk. Han står nämligen på 3.497 segrar hittills i karriären. En pinne till kan komma på Momarken ikväll, där han efter nästan tio års väntan får chansen till revansch med sonen Görans snart 17-faldige miljonär <strong>Lionel</strong> (e. Look de Star).<br>Cato körde nämligen sonens häst i ett kvalopp och en start (diskvalificerad för galopp) som treåring 2013. Sedan dess har han inte fått chansen. Förrän ikväll alltså.<br>– <em>Jag blev överraskad själv. Göran hade inte sagt något om det och jag upptäckte det i listorna. En tevlig överraskning och jag blev både glad och nervös på samma gång. Det ska bli roligt att sitta upp bakom hästen igen och vi får hoppas att båda gamlingarna är i form</em>, sade Cato Antonsen till norska Trav- og Galopp-Nytt.</p>



<p>Lionel gjorde comeback på nyårsafton efter årslång frånvaro med en andraplats, innan han fick nöja sig med sjättepriset på Bjerke för knappt två veckor sedan i senaste starten. Totalt har hingsten gjort 113 starter (30-18-11).</p>



<p><strong>Startlista, 2.140 meter autostart:</strong><br><em>Förstapris: 18.000 norska kronor</em></p>



<ol class="wp-block-list">
<li>Ivanhoe (e. Chocolatier) – Per Oleg Midtfjeld</li>



<li>Mikkel H.R. (e. Revenue) – Åsbjörn Tengareid</li>



<li>Secret Snap (e. Ens Snapshot) – Erlend Rennesvik</li>



<li>Hands Down (e. Main Wise As) – Morten A Pedersen</li>



<li>Hell Patrol (e. Yankee Glide) – Magnus Teien Gundersen</li>



<li>High Glider (e. Yankee Glide) – Lars Anvar Kolle</li>



<li>Lionel (e. Look de Star) – Cato Antonsen</li>
</ol>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/04/lionelpris-617x309.jpg" alt="" class="wp-image-21588"/><figcaption class="wp-element-caption">Göran Antonsen med sin ögonsten Lionel. Foto Mia Törnberg/Sulkysport</figcaption></figure>



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



<p class="has-drop-cap">5 Är du intresserad av en betäckning i <strong>Bold Eagle</strong>,<strong> Love You</strong>, <strong>Timoko</strong> eller någon annan avelshingst och samtidigt göra en god gärning? Ikväll kl 19.00 avslutas hos ASVT en välgörenhetsauktion på internet, där hingstägare till 24 avelshingstar skänkt varsin betäckningsrätt för 2023. Dessa går nu att bjuda på och summan går oavkortat till stiftelsen Olle Goops Minne.</p>



<p>I samband med Olle Goops bortgång startades insamling av medel för att ombilda Björntaget till en stiftelse i Olle Goops Minne efter önskemål från familjen Goop.</p>



<p>Av de 24 avelshingstarna är nio födda i Frankrike, nio är svenskfödda och sex födda i USA. Förutom betäckningsrätterna säljs två starthästar och två fölston.</p>



<p><a href="https://auktion.asvt.se/purchase/" target="_blank" rel="noreferrer noopener">Här går det att se alla avelshingstar och bjuda på betäckningsrätterna.</a></p>



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



<p class="has-drop-cap">6 Två svensktränade hästar prövar lyckan på Vincennes (16.38) under kvällen. Magnus Dahlén nyttjar Matilde Herleiksplass ovanpå <strong>Vincent As</strong> (e. Muscle Massive) i inledningsloppet Prix de Lannemezan (€53.000) där sadelhästarna slåss om segerchecken på 23.850 euro.</p>



<p>Björn Goop finns därtill representerad då Yoann Lebourgeois kör hans <strong>Inductif</strong> (e. Up And Quick) i Prix Jean Et Andre de la Vaissiere (€33.000) för femåriga hingstar och valacker.</p>



<p><a rel="noreferrer noopener" href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2023-02-03/" target="_blank">Här kan du ta del av dagens startlistor till tävlingarna på Vincennes.</a></p>



<p><strong>Såhär gick det för gårdagens svenskintressen på Vincennes:</strong></p>



<p><em>Hästnamn (far) – tränare – placering – intjänade prispengar</em></p>



<ul class="wp-block-list">
<li>Holly Go Lightly (e. Västerbo Prestige) – Tomas Malmqvist – 5:a – 1.950€</li>



<li>Iliade (e. Varenne) – Pierre Levesque – 4:a – 2.640€</li>



<li>Hulken Sisu (e. Readly Express) – Nicolas Bazire – 1:a – 22.950€</li>



<li>Howdy Quick (e. Up and Quick) – Laurent Claude Abrivard – 2:a – 12.750€</li>



<li>Hat Trick (e. Maharajah) – Jarmo Niskanen &#8211; oplacerad</li>



<li>Beckham (e. Napoleon Bar) – Magnus Dahlén – diskvalificerad</li>
</ul>



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



<p class="has-drop-cap">7 Efter seger i försök och final av Diamantstoet samt det Första Testet inför Stochampionatet så framstod <strong>LaFerrari Dimanche </strong>(e. Brad de Veluwe) 1.12,9am/652.400 kr som en av kullens mest intressanta ston, men någon mer seger blev det inte under fyraåringssäsongen.<br>Sedan årsskiftet har stoet bytt regi och gått från Carl-Otto Göransson till Halmstadkollegan Rick Ebbinge.</p>



<p>Det är Firma Stall Dimanche som äger och har fått upp det femåriga stoet som segrat i fem av 17 starter under karriären.</p>

Fokustema
Morgonsvepet
Läs senare
Nu börjar derbyresan
Att derbyresan startar för kallbloden denna kväll, om Australiens motsvarighet till Elitloppet som avgörs under morgonkvisten samt en tvåfaldig Diamantstovinnare som bytt regi går bland annat att läsa i dagens morgonsvep.
