
<p class="has-drop-cap">1Vårfavoriten – ger det loppet besked om vem som vinner Svenskt Travkriterium på Solvalla ett knappt halvår senare? Både ja och nej. Hästarna som tagit dubbeln Vårfavoriten/Kriteriet är inte många, men det finns några medan Vårfavoriten började köras 1980.</p>



<p>Tre gånger har det nämligen hänt i historien. 1986 <strong>Piper Cub </strong>(e. Tibur) – Stig H Johansson, 1996 <strong>Remington Crown</strong> (e. Lord Of All) – Robert Bergh, och 2004 Conny Nobell (e. Pearsall Hanover) – Björn Goop. Dessutom vann superstoet Hilda Zonett (e. Spotlite Lobell) Vårfavoriten för ston år 2000 innan hon sopade till hingstarna i Kriteriet tillsammans med Robert Bergh.</p>



<p>Diederik Meilinks valack<strong> Romulus Tooma </strong>(e. S.J.’s Caviar) visade mest som tvååring av kvällens nio deltagare, då han slutade tvåa i Svensk Uppfödningslöpning. Axevallaamatören Mikael Fellbrandts <strong>Vikens Love Kill </strong>(e. Tobin Kronos) har färskaste och starkaste fiormintrycket efter vinsten i Breeders Crown-försöket på Färjestad förra veckan.</p>



<p>Och på tal om Hilda Zonett – hennes syster<strong> Ester Zonett</strong> (e. Pine Chip) är mamma till Daniel Wäjerstens hopp i Vårfavoriten <strong>August Zonett </strong>(e. Pojke Kronos).</p>



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



<p class="has-drop-cap">2Stona har haft en egen klass i Vårfavoriten sedan 1993 då <strong>Handbag</strong> (e. Ditka Hanover) och Stig Lindmark segrade. Handbag fortsatte att utvecklas som äldre och blev ett elitsto i Roger Walmanns regi. Hon vann nästan hälften av livets starter – 38 av 79 – och sprang in över 4,2 miljoner kronor.</p>



<p>Förutom att Hilda Zonett vann Kriteriet efter att ha vunnit Vårfavoriten för ston på vårkanten, så har två treåriga damer dubblerat i Vårfavoriten och Oaks. Den gemensamma nämnaren bakom dessa är Örjan Kihlström som kusk. 2001 segrade han med Stefan Hultman-tränade<strong> Pine Dust</strong> (e. Pine Chip) och två år senare var Roger Walmanns<strong> Giant Diablo</strong> (e. Supergill) segervapnet.</p>



<p>Ifjol var det Bergsåkeramatören Ola Åsebö i topp med<strong> Coral Coger </strong>(e. Ken Warkentin), som ett par månader senare segrade i långa E3. Åsebö finns med även i årets upplaga genom <strong>Pretty Be Linda </strong>(e. Varenne) som vann debuten som tvååring och slutade tvåa i finalen av Norrlands Elitserie för tvååringar.</p>



<p>Mest meriterade i loppet är annars Svampentvåan <strong>Melba Westwood </strong>(e. Quite Easy), <strong>Charma</strong> (e. Love You), som vann en avdelning i Margaretas Tidiga Unghästserie i februari, och nybakade Breeders Crown-vinnaren<strong> Ballerina Girl </strong>(e. Father Patrick).</p>



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



<p class="has-drop-cap">3Kvällens V86-omgång delar Solvalla (första start 18.15) med Norge och Bjerke (första start 18.27). Solvalla bjuder förutom treåringsloppen, på sprinteruppgörelsen The Onions lopp med 2021 års Elitloppsvinnare bakom startbilen. Daniel Redéns<strong> Don Fanucci Zet </strong>(e. Hard Livin) har gjort en start i år efter att ha varit borta sedan galoppen i Elitloppsförsöket förra året.</p>



<p>Han möter tre konkurrenter som likaså har Elitloppsdeltagande på sitt cv i form av <strong>Night Brodde </strong>(e. Up and Quick), <strong>Click Bait</strong> (e. Cantab Hall) samt <strong>Milliondollarrhyme</strong> (e. Ready Cash)<strong>. Night Brodde </strong>var Elitloppsfinalist 2022, Click Bait är dubbel Elitloppsdeltagare och var femma i finalen 2022, medan <strong>Milliondollarrhyme</strong> är trefaldig Elitloppsdeltagare och som bäst fyra i finalen både 2019 och 2020.</p>



<figure class="wp-block-image aligncenter size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/milliondollarrhyme-617x333.jpg" alt="" class="wp-image-167770"/><figcaption class="wp-element-caption">Milliondollarrhyme startar i The Onions lopp. Hedlund/Sulkysport</figcaption></figure>



<p>På Bjerke dyker fjolårets norske Kriterietrea upp. Frode Hamre-tränade <strong>Nelson Daytona</strong> (e. Father Patrick) tog bronsplatsen i Kriteriet bakom överlägsne <strong>Just Like Heaven</strong> (e. Maharajah) och var knappt slagen av <strong>Klinger</strong> (e. Maharajah) om andraplatsen. Klinger startar för övrigt också ikväll – på Solvalla.</p>



<p>Kriterieframgången till trots, Nelson Daytone blev segerlös som treåring, men inledde fyraåringssäsongen på bästa sätt med lätt seger på Bjerke för tre veckor sedan.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/04/17v86.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna på Bjerke och Solvalla.</a></p>



<p>––> Sulkysports spelstuga med viktiga punkter, spikar, drag och favoriter i fara publiceras som vanling klockan 12.00 idag.</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-04-17_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-04-17_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">4Det kryllar av svenska inslag när det travas i den franska Champagnestaden Reims (första start kl. 12.00) under onsdagslunchen.</p>



<p>Sulkyloppet Prix de la Ville de Reims (€27.000) ser inte mindre än sex blågula travare bland de 14 deltagarna varav tre också är svensktränade.<br>Tomas Malmqvist nyttjar Mathieu Mottier bakom<strong> La Sassicaia </strong>(e. Bold Eagle), Jörgen Westholm har Florian Desmigneux som kusk bakom <strong>Ninepoints Lasse</strong> (e. Uncle Lasse) och Johan L Sundgren kör Björn Goops<strong> Global Above All </strong>(e. Love You).<br>Fältet innehåller därtill exporterna <strong>Lucky Guy Boko</strong> (e. Broadway Hall), <strong>Trumpie</strong> (e. Brad de Veluwe) och<strong> Lee Harvey Bros</strong> (e. Readly Express).</p>



<p>I sadelloppet Prix du Champagne de Castelnau (€30.000) är fyra av de tio deltagarna svenskfödda.<br>Exporterna <strong>Madame af Djupmyra</strong> (e. Formula One), <strong>Zlatan Knick</strong> (e. Going Kronos) och<strong> Huis Clos</strong> (e. Bird Parker) slåss med Jörgen Westholms <strong>Ara</strong> (e. Maharajah) om segerchecken på 13.500 euro.</p>



<p>Westholm startar därtill Stall Courants Face Time Bourbon-son <strong>Kingpin</strong> i Prix du Trotteur Francais (€21.000) för fyraåringar.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/reims-2024-04-17/" target="_blank" rel="noreferrer noopener">Här kan du ta del av dagens startlistor till tävlingarna i Reims.</a></p>



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



<p class="has-drop-cap">5Jerry Riordan har stärkt upp stallet med en mycket spännande treåring från Italien. Det handlar om <strong>First Time Roc</strong> (e. Face Time Bourbon) 1.13,2ak/232.950 kr som inlett karriären med fyra segrar på dussinet starter och totalt nio pallplaceringar.</p>



<p>Modern <strong>Zarina Roc</strong> (e. Filipp Roc) 1.12,8/€130.781 vann Grupp I-loppet Gran Premio Anact – Femmine (€100.100) som tvååring samt ett försök till Oaks del Trotto efterföljande säsong.</p>



<p>First Time Roc tog sin senaste seger i Turin den 27 mars på 1.14,1a/2.060 meter och är startberättigad i Breeders Course på svensk mark.</p>



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



<p class="has-drop-cap">6Benoït Robins Prix de Paris-vinnare<strong> Hussard du Landret </strong>(e. Bird Parker) är en av många önskad gäst på Solvalla under Elitloppshelgen, men i gårdagens upplaga av Paris-Turf slingrade sig Robin när han fick frågan om just Elitloppet är aktuellt för hans sjuåring.<br>– Nu fokuserar vi med full kraft på lördagens Grup I-lopp. Jag har inte bestämt något lopp efter detta under de kommande veckorna, varken i Frankrike eller utomlands, sade Robin.</p>



<figure class="wp-block-image alignright size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/02/hussardulandretprixdeparisletrotphoto-617x347.jpg" alt="" class="wp-image-555717"/><figcaption class="wp-element-caption">1.11,9 travade Hussard du Landret över 4.150 meter vid sin seger i Prix de Paris i februari. Foto: Le Trot</figcaption></figure>



<p>Lördagens start som stundar sker på Enghien och då handlar det om <strong>Prix de l’Atlantique </strong>(€200.000) över 2.150 meter autostart. I comebacken för två veckor sedan fick Hussard du Landret nöja sig med en sjundeplats trots att han kutade 1.11,4/2.700 meter.<br>– Hästen hade tränat bra, men tävlade inte på &#8221;120 procent&#8221; av sin kapacitet. Han blev trött till slut, men kollapsade inte på något vis. Jag var inte besviken på hans prestation, säger Robin.</p>



<p><a href="https://sulkysport.se/13-kvar-i-prix-de-latlantique-2/" target="_blank" rel="noreferrer noopener">Här kan du ta del av vilka hästar som kvarstår i lördagens Prix d&#8217;Atlantique.</a></p>



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



<p class="has-drop-cap">7Vid årsskiftet lämnade Stig H Johansson in proffstränarlicensen efter en fenomenal karriär och totalt 8.206 segrar som tränare, men igår i Bollnäs var Stig H Johansson en vinnare igen. Stig H och hustrun Karin äger nämligen en liten del i kallblodet <strong>Gulldus</strong> (e. Wikvinn), som tränas av Solvallaamatören Göran Molander.</p>



<p>Gulldus har i vår kommit tillbaka efter nästan årslångt uppehåll och tredjeplatsen i comebacken följdes av seger vid gårdagens lunchtävlingar i Bollnäs. Molander serverade Gulldus en resa i rygg på ledande B.W.Raz, vred ut i andraspår 300 kvar och Gulldus avgjorde säkert på nya rekordet 1.29,0a/1.640 meter.<br>– Stig har kört lite jobb med Gulldus och varit en mentor. Sedan har vi haft tillgång till träningsbanorna på Stora Alby och kan köra jobb där, sade Göran i segerintevjun.</p>



<p>Gulldus har gjort 15 starter (2-2-2) och sprungit in 116.500 kronor.</p>

Fokustema
Morgonsvepet
Läs senare
Ett steg mot Kriteriet?
Om kvällens klassiker Vårfavoriten på Solvalla, den forne Elitloppsvinnaren som kan hedra en annan Elitloppsvinnare och om Stig H Johanssons hästägarseger i Bollnäs rapporterar vi bland annat i veckans tredje morgonsvep.
