
<p class="has-drop-cap wp-block-paragraph">1 De mörka molnen över Roms trav- och galoppbana Capannelle har brustit i ett fullskaligt oväder. Efter månader av osäkerhet står det klart att Roms kommun officiellt ger upp försöken att hålla banan öppen under våren och sommaren. Nu väntar ett akut krismöte för att rädda banan.</p>



<p class="wp-block-paragraph">Tecknen på att något var fel i den italienska huvudstaden har funnits länge. Redan när tävlingskalendern för 2026 fastställdes, noterade branschen med förvåning att det italienska travderbyt för första gången någonsin hade flyttats till Turin.</p>



<p class="wp-block-paragraph">Det som då anades som en försiktighetsåtgärd har nu visat sig vara början på en djup kris. Enligt officiella källor har Roms kommun öppet deklarerat att man inte kan ”garantera hästkapplöpning på Capannelle” under de kommande månaderna.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/tordivalle1-617x257.jpg" alt="" class="wp-image-820577"/><figcaption class="wp-element-caption">Roms tidigare travbana Tor di Valle stängdes 2013.</figcaption></figure>



<p class="wp-block-paragraph">Verksamheten ställs in fram till september, och i branschen talar man om att det krävs ett ”mirakel” för att hästarna överhuvudtaget ska återvända till arenan i höst. Med anledning av det akuta läget har det italienska jordbruksministeriet, MASAF, agerat snabbt och kallat företrädare för både trav- och galoppsporten till ett krismöte.</p>



<p class="wp-block-paragraph">Huvudagendan för mötet är att hantera de omedelbara konsekvenserna av nedstängningen och nå en överenskommelse om hur de förlorade tävlingsdagarna ska fördelas på andra banor i landet.</p>



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



<p class="has-drop-cap wp-block-paragraph">2 Travprofilen Björn ”Bernie” Norén är en riktig mångsysslare i branschen, sedan han vände hem till Sverige för tiotalet år sedan efter många år på andra sidan Atlanten. Han är manager för Knutsson Trotting, styrelseledamot i Västergötlands Travsällskap, gästexpert i ATG Live – och amatörtränare med fem hästar på sin träningslista.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2017/11/bjornnorenlinaalm-617x507.jpg" alt="" class="wp-image-15052"/><figcaption class="wp-element-caption">Björn Norén. Foto: Lina Alm.</figcaption></figure>



<p class="wp-block-paragraph">Den vassaste för dagen är femårige, Knutsson-ägde <strong>Laprisamata </strong>(e. Six Pack), som hade ett gott fjolår, även om det kom en svacka och uppehåll under sommaren. Säsongen avslutades i december med V85-vinst på Åby och fjärdeplatsen i Sylvesterloppet på hemmaplan på nyårsafton.</p>



<p class="wp-block-paragraph">I år har det också börjat bra med silverpengen i klass I-försöket på Färjestad för knappt tre veckor sedan. Och igår blev det seger på Axevalla med <strong>Hipster K.</strong> (e. Sebastian K.)</p>



<p class="wp-block-paragraph">Ikväll på <strong>Åby</strong> (första start 18.20) har Laprisamata utmärkta förutsättningar att bärga årets första seger. Springspår på tillägg i ett B-tränarlopp och André Eklundh i vagnen talar för en fullträff.</p>



<p class="wp-block-paragraph">Laprisamata finns med på V64-kupongen, där det ligger drygt 1,2 miljoner kronor extra i sexrättspotten i jackpotpengar, vilket gör att potten kommer att uppgå till minst 4,5 miljoner.</p>



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



<p class="has-drop-cap wp-block-paragraph">3 Drygt 20 varmblodiga treåringar har vunnit lopp på svensk mark i år. Eskilstunatränaren Sybille Tinter har fem treåringar på träningslistan – och tre av dem finns bland årets treåringsvinnare. Tillsammans har de tagit fem segrar hittills i år.</p>



<p class="wp-block-paragraph">En av dem är danskfödde <strong>Max Million </strong>(e. Beer Summit), som inlett karriären fläckfritt och är obesegrad efter två starter. Idag på lunchbanan <strong>Gävle</strong> (första start 12.20) är Max Million anmäld till delningspropositionen upp till miljonen intjänat, som utgör fem åttondelar av tävlingsdagen.</p>



<p class="wp-block-paragraph">Max Million är ensam om att bara ha två starter innanför västen, men är samtidigt den ende tillsammans med Daniel Parlings <strong>Macho Cabrio B.B. </strong>(e. Djali Boko) om att ha fått segerdefilera två gånger hittills i karriären.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2026/02/260219.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2026/02/260219.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till torsdagens tävlingar.</a></p>



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



<figure class="wp-block-image alignright size-full"><img src="https://sulkysport.se/wp-content/uploads/2026/02/angusgarrardudc2026rj0s3gnojcrtfmng2e8x3mm3df043gkrxaefx7ath4.jpg" alt="" class="wp-image-820586"/><figcaption class="wp-element-caption">Angus Garrard</figcaption></figure>



<p class="has-drop-cap wp-block-paragraph">4 Årets upplaga av Ladbrokes Ultimate Driver på Albion Park den 20-21 februari saknar svenskt deltagande. Ifjol fanns Björn Goop på plats, men i år saknas tvåbenta kuskar från Europa. Inte heller någon från USA åker till Australien för att tävla, men väl toppkusken James MacDonald från Kanada och han ställs mot åtta kuskar från Australien och en från Nya Zeeland.</p>



<p class="wp-block-paragraph">Regerande mästaren <a href="https://sulkysport.se/21-aring-ultimate-driver/" data-type="link" data-id="https://sulkysport.se/21-aring-ultimate-driver/" target="_blank" rel="noreferrer noopener">Angus Garrad</a>, 22 år, finns däremot med. Totalt ligger 350.000 dollar i potten.</p>



<h2 class="wp-block-heading">Deltagare, land</h2>



<ul class="wp-block-list">
<li><strong>Zachary Butcher,</strong> Nya Zeeland</li>



<li><strong>Gary Hall Jr</strong>, Australien</li>



<li><strong>Luke McCarthy</strong>, Australien</li>



<li><strong>Peter McMullen</strong>, Australien</li>



<li><strong>Robbie Morris</strong>, Australien</li>



<li><strong>Cam Hart</strong>, Australien</li>



<li><strong>James Herbertson</strong>, Australien</li>



<li><strong>Angus Garrard</strong>, Australien</li>



<li><strong>Trista Dixon,</strong> Australien</li>



<li><strong>James MacDonald</strong>, Kanada</li>
</ul>



<p class="wp-block-paragraph"><a href="https://www.theultimatedriver.com.au/" data-type="link" data-id="https://www.theultimatedriver.com.au/" target="_blank" rel="noreferrer noopener">Läs mer om The Ultimate Driver här.</a></p>



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



<p class="has-drop-cap wp-block-paragraph">5 San Siro-banan i Milano bjuder på ett Grupp II-lopp för äldre italienskfödda travare på söndag – Gran Premio E.N.C.A.T. (€55.000) – och både Erik Bondo och Alessandro Gocciadoro kommer med en duo i medeldistansloppet.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/skarmavbild20260218kl.13.23.40-617x386.jpg" alt="" class="wp-image-820582"/><figcaption class="wp-element-caption">Dubhe Prav.</figcaption></figure>



<p class="wp-block-paragraph">Erik Bondo plockar ut <strong>Every Time Winner </strong>och <strong>Far West Bi</strong>, medan Alessandro Gocciadoro startar Kungapokalsvinnaren <strong>Free Time Jepson</strong> och <strong>Dali Prav</strong>.</p>



<p class="wp-block-paragraph">En intressant årsdebut gör <strong>Dubhe Prav </strong>(e. Robert Bi) för Santo Mollo och han avslutade säsongen med att vinna försök och final i Gran Premio Palio dei Comuni (€154.000) och tidigare under hösten blev det också seger i Gran Premio Gaetano Turilli (€154.000) i Rom.</p>



<p class="wp-block-paragraph"><strong>Gran Premio E.N.C.A.T. </strong>(€55.000)<br>Äldre travare.<br><em>2.100 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>Eminem Font</strong> (e. Ringostarr Treb) – Enrico Montagna/Mauro Baroncini</li>



<li><strong>Fil Ek</strong> (e. Ringostarr Treb) – Pietro Gubellini/Fausto Barelli</li>



<li><strong>Enki Brown Effe</strong> (e. Manofmanymissions) – Enrico Bellei/Holger Ehlert</li>



<li><strong>Follia d’Esi </strong>(e. Ringostarr Treb) – Marco Stefani/Mauro Baroncini</li>



<li><strong>Every Time Winner </strong>(e. Face Time Bourbon) – Francesco Facci/Erik Bondo</li>



<li><strong>Far West Bi </strong>(e. Muscle Hill) – Antonio di Nardo/Erik Bondo</li>



<li><strong>Free Time Jepson </strong>(e. Face Time Bourbon) – Alessandro Gocciadoro</li>



<li><strong>Emma dei Veltri </strong>(e. Maharajah) – Vincenzo Luongo/Gennaro Casillo</li>



<li><strong>Funky Roc</strong> (e. Nad al Sheba) – Filippo Rocca</li>



<li><strong>Dali Prav </strong>(e. Donato Hanover) – Rene Legati/Alessandro Gocciadoro</li>



<li><strong>Banderas Bi</strong> (e. Ganymede) – Roberto Vecchione/Alessio Di Basco</li>



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



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



<p class="has-drop-cap wp-block-paragraph">6 En svenskfödd travare på <strong>Vincennes </strong>(första start kl. 13.55) och två i <strong>Toulouse </strong>(kl. 16.32) – så ser förutsättningarna ut för det blågula ”laget” på fransk mark imorgon.</p>



<p class="wp-block-paragraph">Nicolas Bazire startar <strong>Onana Boko</strong> (e. Trixton) sadelloppet i Prix de Mortagne (€46.000) över 2.850 meter och den femårige hingsten jagar första årssegern.</p>



<p class="wp-block-paragraph">Till Toulouse åker Christoffer Eriksson med <strong>Humanity Pellini </strong>(e. Up and Quick) och bland motståndarna i Prix de Grosbois (€35.000) finns Vincent Martens <strong>Kingslayer Pellini </strong>(e. Up and Quick). Distansen är 2.750 meter med bilstart och 15.750 euro väntar vinnaren.</p>



<p class="wp-block-paragraph">Här hittar du startlistorna till <a href="https://www.letrot.com/courses/programme/2026-02-19/3103" data-type="link" data-id="https://www.letrot.com/courses/programme/2026-02-19/3103" target="_blank" rel="noreferrer noopener">Toulouse</a> och <a href="https://www.letrot.com/courses/programme/2026-02-19/7500" data-type="link" data-id="https://www.letrot.com/courses/programme/2026-02-19/7500" target="_blank" rel="noreferrer noopener">Vincennes</a>.</p>



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



<p class="has-drop-cap wp-block-paragraph">7 Hela 290.000 nyzeeländska dollar betalades det för en dotter till <strong>Walner</strong> och <strong>Egee Money </strong>på National Standardbred Yearling Sale i Christchurch på Nya Zeeland. Stonewall Stud låg bakom rekordköpet för en travare.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2026/02/lot258walneregeemoneyfilly1536x1024-617x411.jpeg" alt="" class="wp-image-820564"/><figcaption class="wp-element-caption">Rekordpris för en toppstammad dotter med Walner som far och ett starkt franskt möderne. </figcaption></figure>



<p class="wp-block-paragraph">– Att ha sådana världsklassblodslinjer tillgängliga på den här sidan av världen är verkligen unikt, så att se Walner-stoet nå den sortens pengar var välförtjänt, sade Cam Bray på auktionsfirman NZB Standardbred.</p>



<p class="wp-block-paragraph">Franskfödda modern <strong>Egee Money </strong>(e. Love You), 1.13,5/$78.180, har en startande avkomma sedan tidigare; <strong>No Money Honey</strong> (e. Volstead), 1.12,1/$28.580. Egee Money är i sin tur undan <strong>Return Money</strong> (e. Corot), 1.12,0ak/€801.610, vars främsta avkommor är <strong>Flash Money</strong> (€268.480), <strong>Je Te Cherce</strong> (€244.900), <strong>Be Cash Money </strong>(€124.680) och <strong>Derby Destin</strong> (€121.290).</p>



<p class="wp-block-paragraph">Vidare såldes en hingst efter <strong>Volstead</strong> och <strong>Our Golden Kenny</strong> för 110.000 dollar. Lika mycket betalades det för en hingst efter <strong>Timoko </strong>och <strong>Dwindle Mist</strong>.</p>



<p class="wp-block-paragraph"><strong>Our Golden Kenny</strong> (e. Love You), 1.18,6l*/$22.599, har sin första avkomma i Volstead-sonen. Själv ingår hon i samma syskonskara som <strong>Princess Kenny </strong>($83.588) och <strong>Queen Kenny</strong> ($98.382) – mor till <strong>Queen Elida</strong> ($1.176.080).</p>



<p class="wp-block-paragraph">Sonen till Timoko är undan <strong>Dwindle Mist </strong>(e. Sundon), 1.15,1/$43.000, vilken har sin främsta avkomma i <strong>Harry Stamper </strong>(e. Majestic Son) 1.12,5/$240.585.</p>



<p class="wp-block-paragraph"><a href="https://www.nzbstandardbred.co.nz/sales/26syc" data-type="link" data-id="https://www.nzbstandardbred.co.nz/sales/26syc" target="_blank" rel="noreferrer noopener">Samtliga resultat från auktionen hittar ni här.</a></p>



<p class="wp-block-paragraph"><strong>Fotnot:</strong> det tidigare rekordet var från 2020 och då klubbades hingsten <strong>Toro Stride</strong> (e. Love You-Queen Kenny) för 280.000 dollar.</p>
