
<p class="has-drop-cap">1 Årets Travare har delats ut i USA sedan 1970 och inte vid något tillfälle har en tvååring lyckats ta hem den titeln. Kan det vara dags i år?</p>



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2025/02/danpatchawardssm.jpg" alt="" class="wp-image-689044"/></figure>



<p>Marcus Melander-tränade <strong>Maryland </strong>(e. Chapter Seven-Crucial), 1.09,5*/$1.227.695, fick inte bara överlägset mest röster bland de tvååriga hingstarna/valackerna utan var också den häst som förordades med högsta antalet röstsedlar i samtliga kategorier. </p>



<p>Är det en fingervisning inför söndagens Dan Patch Award-gala i Florida?</p>



<p>Nio starter utmynnade i sex vinster och där ingick triumfer i Mohawk Million (C$1.000.000), Breeders Crown ($700.000), William Wellwood Memorial (C$575.000), Peter Haughton Memorial ($390.000).</p>



<p>Äger Maryland gör Courant Inc., PCW Racing LLC, Holly Lane Stud East LTD, Steve Stewart &#038; Robin Thörn Stable.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/02/marylandupp1ret240801adamstromstalltz-617x433.jpg" alt="" class="wp-image-689045"/><figcaption class="wp-element-caption">Blir Maryland årets travare i USA? Foto: Adam Ström/stalltz.se</figcaption></figure>



<p>På United States Harness Writers Association <a href="https://www.facebook.com/USHarnessWriters/" data-type="link" data-id="https://www.facebook.com/USHarnessWriters/" target="_blank" rel="noreferrer noopener">facebooksida</a> går det att följa galan med start klockan 18.30 amerikansk tid.</p>



<p><strong>Fotnot:</strong> Årets Häst för trav och passgångare har utsetts sedan 1947 i USA och vid endast ett tillfälle har titeln gått till en tvåårig travare. Nevele Pride utsågs inte bara till Årets Häst som tvååring 1967, utan även som tre- och fyraåring.</p>



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



<p class="has-drop-cap">2 Jackpotorgien på V64 fortsätter. Tio vardagskvällar i februari har det varit V64-spel och sex gånger av dessa har det funnits extra jackpotpengar i sexrättspotten.</p>



<p>Ikväll är det dags igen – för fjärde V64-omgången i rad – när <strong>Gävles</strong> omgång spetsas med 1,3 miljoner kronor extra i potten för sexorna.</p>



<p>På jackpotfronten i övrigt noteras att ATG:s fonderade medel av bunkrade jackpotpengar på V75 nu uppgår till 12.913.219 kronor. Sedan april förra året plockas nämligen 20 procent av alla jackpotpengar i ordinarie omgångar (främst lördagar) undan till fonden, liksom samtliga jackpotkronor från övriga V75-omgångar.</p>



<p>Nästa multijackpot på V75 blir avslutningen av Springrace och V75-omgången på Romme på påskdagen den 20 april, där hela eller delar av de bunkrade pengarna läggs in i sjurättspotten.</p>



<p><strong>Den föregås av V75 tre dagar i rad:</strong></p>



<ul class="wp-block-list">
<li>17 april – skärtorsdag – Gävle</li>



<li>18 april – långfredag – Färjestad</li>



<li>19 april – påskafton – Klosterskogen</li>
</ul>



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



<p class="has-drop-cap">3 Sex segrar på elva starter i Danmark, men segerlös i både Belgien och Sverige efteråt. Är det dags att spräcka nollan på svensk mark för Markus B Svedberg-tränade, åttaårige <strong>Hattivatti</strong> (e. Singalo) i ett trekilometerslopp i <strong>Gävle</strong> (första start 18.20) ikväll?</p>



<p>Den franskfödde valacken har varit berest i livet. Han inledde med att kvala i Frankrike, såldes till Danmark där han tävlade hos Morten Juul och vann på 1.14,0ak i livets andra start. </p>



<p>Via Kristina Westerholm och Jarmo Niskanen (tre starter med ett femtepris som bäst) hamnade Hattivatti hos Markus B Svedberg i oktober förra året. Där har det blivit tre pallplatser på fyra försök, men Hattivatti väntar fortfarande på första segern. Kvällens uppgift sker över 3.140 meter i Vinterstayern.</p>



<p>Gävle är enda svenska bana som tävlar denna torsdag och i övrigt ikväll blir det  ett möte mellan två obesegrade Nuncio-döttrar i ett stolopp. Både Fredrik Wallins <strong>Global Genesis</strong> och Björn Röcklingers<strong> Inyourface C.G.</strong> inledde sina tävlingskarriärer med vinst i debuten och gör nu livets andra starter.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/02/20v64.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2025/02/20v64.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till Gävles tävlingar.</a></p>



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



<p class="has-drop-cap">4 Alessandro Gocciadoros topptravare Expo Wise As (e. Ready Cash) gör sin andra start för säsongen på söndag i Gran Premio ENCAT (€35.200) i Milano efter ha galopperat från start i årsdebuten och reparerat starkt till tredjeplatsen.</p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/07/expowiseas2024.jpg" alt="" class="wp-image-615609"/><figcaption class="wp-element-caption">Alessandro Gocciadoros trefaldige Grupp I-vinnare Expo Wise As Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Fjolåret var inte speciellt framgångsrikt och sju starter – en seger i Glenn Kosmos Memorial (€24.200) på Vermo – utmynnade i 13.720 intjänade euro.</p>



<p>Däremot var han framgångsrik som treåring med segrar i det italienska Derbyt och Gran Premio Orsi Mangelli, men även i långa E3 och Norrlands Elitserie. Han var också tredje vinstrikaste italienskfödd travare med 603.346 euro under treåringssäsongen.</p>



<p><strong>Gran Premio ENCAT</strong> (€35.200)<br>Äldre travare.<br><em>2.100 meter, autostart.</em></p>



<p><strong>Namn (far) – Körsven</strong></p>



<ol class="wp-block-list">
<li><strong>Diamond Frances</strong> (e. Exploit Caf) – Andrea Farolfi</li>



<li><strong>Expo Wise As</strong> (e. Ready Cash) – Alessandro Gocciadoro</li>



<li><strong>Cathrinelle</strong> (e. Filipp Roc) – Filippo Rocca</li>



<li><strong>Dylan Dog Font</strong> (e. Ringostarr Treb) – Vincenzo Luongo</li>



<li><strong>Chance Ek</strong> (e. Nad al Sheba) – Pietro Gubellini</li>



<li><strong>Edy Girifalco Gio</strong> (e. Victor Gio) – Giampaolo Minnucci</li>



<li><strong>Dubhe Prav</strong> (e. Robert Bi) – Santo Mollo</li>



<li><strong>Dali Prav </strong>(e. Donato Hanover) – Massimo Castaldo</li>



<li><strong>Corallo Pisano</strong> (e. Louvre) – Matteo Legnani</li>



<li><strong>Desiderio d’Esi</strong> (e. Robert Bi) – Marco Stefani</li>
</ol>



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



<p class="has-drop-cap">5 Det är tunt med svenskar på <strong>Vincennes</strong> idag (första start kl. 13.55) och i det enda loppet som är öppet för europafödda travare – monté-löpningen Prix de Mortagne (€46.000) – saknas blågult deltagande.</p>



<figure class="wp-block-image alignright size-sulky-liten2"><img src="https://sulkysport.se/wp-content/uploads/2021/05/marienorberg-350x302.jpg" alt="" class="wp-image-160828"/><figcaption class="wp-element-caption">Marie Norberg.</figcaption></figure>



<p>Däremot selar Marie Norberg ut egenägda<strong> Lady d’Elfe </strong>(e. Bon Copain) i ett stolopp – Prix de Pontault-Combault (€40.000) – över 2.700 meter med 18.000 euro i förstapris och har engagerat Mathieu Mottier.</p>



<p>Två starter i år på Vincennes har resulterat i en tredje- och fjärdeplats i Prix de Guerlesquin respektive Prix de Darnetal. Ifjol blev det en vinst i Prix des Ardennes (€12.000) i Chalons-en-Champagne och då satt Marie Norberg själv i sulkyn.</p>



<p><a href="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-02-20/" data-type="link" data-id="https://sulkysport.se/trav-och-galopp/paris-vincennes-2025-02-20/" target="_blank" rel="noreferrer noopener">Här hittar ni startlistorna till dagens tävlingar på Vincennes.</a></p>



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



<p class="has-drop-cap">6 För svenskt vidkommande är Greg Sugars mest känd som kusk till Elitloppsdeltagaren <strong>Just Believe</strong>. Igår passade han på att ta sin 4.000:e seger bakom passgångaren <strong>Festinalente </strong>(e. Shadow Play) på Bendigo.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/05/gregsugars-617x333.jpg" alt="" class="wp-image-450192"/><figcaption class="wp-element-caption">Greg Sugars. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>För att nå det målet har det krävt 24.086 starter och 40-årige Greg Sugars har en segerprocent på 17 procent. Han har vunnit 63 Grupp I-lopp och kört in drygt 38 miljoner dollar under sin karriär.</p>



<p>Bästa säsongen hade Sugars säsongen 2019-2020 med 321 vinster och i pengar räknat blev det rekordhöga 3.139.229 dollar.</p>



<h2 class="wp-block-heading">Största segrarna i Australien:</h2>



<p><strong>Namn – Lopp/prissumma</strong></p>



<ul class="wp-block-list">
<li><strong>The Storm Inside</strong> – Australien Pacing Gold ($322.000)</li>



<li><strong>Mr Nickel</strong> – Australien Pacing Gold ($305.000)</li>



<li><strong>Just Believe</strong> – Great Southern Star ($300.000)</li>



<li><strong>Maajida</strong> – Breeders Crown ($300.000)</li>



<li><strong>Just Believe</strong> – Inter Dominion ($265.000)</li>
</ul>



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



<p class="has-drop-cap">7 Franska travförbundet rapporterar att under januari i år togs totalt 1.201 prover och följande kontroller utfördes:</p>



<p>– 921 hästar provtogs efter att ha deltagit i ett lopp.<br>– 38 hästar provtogs vid ankomsten till travbanan, innan de deltog i ett lopp. Dessa särskilda provtagningar organiserades på följande banor: Argentan och Vincennes 4 januari, Cordemais 15 januari, Toulouse 16 och 31 januari samt Lyon-La Soie 30 januari. Vid dessa evenemang provtogs tre hästar vid varje tillfälle.<br>– Två större särskilda insatser organiserades 9 januari i Cagnes-sur-Mer och 24 januari i Saint-Brieuc, då 20 hästar provtogs.</p>



<p>– De 18 hästar som anmälts som startande i Prix de Cornulier, Prix Bold Eagle och Prix d&#8217;Amérique provtogs under de 48 timmar som föregick dessa lopp i respektive hästars stallar.</p>



<p>– Fyra specifika bikarbonatprovtagningar organiserades på Vincennes 5 och 16 januari, Saint-Galmier 19 januari och Angers 29 januari. Under dessa operationer togs prover på 60 hästar och samtliga resultat var negativa.</p>



<p>– 60 hästar provtogs i samband med kval.</p>



<p>– 61 hästar provtogs under träningstester på 16 olika anläggningar.</p>



<p>– Sju prover togs som en del av programmet Longitudinal Monitoring.</p>



<p>Per den 10 februari 2025 hade två förbjudna substanser i kategori I påvisats av de 1 201 prover som togs i januari.</p>

Fokustema
Sju nyheter vid sju (uppdaterad)
Läs senare
Maryland kan bli unik
Spräcker nollan i Gävle? Ensam svensk på Vincennes. Trefaldig Grupp I-vinnare jagar första årssegern och så fortsätter Jackpotorgien på V64.
Det är några av Sulkysports nyheter i morgonsvepet.
Det är några av Sulkysports nyheter i morgonsvepet.
