
<p class="has-drop-cap">1 Idag avgörs försök- och finalloppet Gran Premio Palio dei Comuni (€154.000) i Montegiorgio och senaste blågula segern togs av svenskfödde <strong>Global Trustworthy </strong>(e. Muscle Hill) för Alessandro Gocciadoro. Senast en svensktränad travare toppade i Kommunloppet var Nils Enqvists <strong>Opal Viking</strong> (e. Turnpike Taylor) 2009 och han loppet ytterligare två gånger.</p>



<p>I år ska Björn Goop och <strong>Betting Pacer</strong> (e. Maharajah) försvara de svenska färgerna i Grupp I-loppet. Ytterligare en svenskfödd travare – <strong>Cabasse</strong> (e. Readly Express) – finns med och den Mattia Orlando-tränade travaren körs av Salvatore Luongo</p>



<p>För att ta plats i finalen gäller det att vara bland de fyra främsta.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2023/06/bettingpacer-617x333.jpg" alt="" class="wp-image-458433"/><figcaption class="wp-element-caption">Betting Pacer och Björn Goop. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p><strong>Gran Premio Palio dei Comuni </strong>(€8.250) – försök I:<br>Fyraåriga &#038; äldre hästar.<br><em>1.600 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Ideal San Leandro</strong> (e. Timoko) – Björn Goop</li>



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



<li><strong>Dany Capar</strong> (e. Exploit Caf) – Alessandro Gocciadoro</li>



<li><strong>Ziguli dei Greppi</strong> (e. Uronometro) – Santo Mollo</li>



<li><strong>Cuba del Duomo</strong> (e. Varenne) – Rene’ Legati</li>



<li><strong>Donrodrigo</strong> (e. Angus Hall) – Daniele Cuglini</li>



<li><strong>Billy Pan</strong> (e. Leben Rl) – Marcello Di Nicola</li>



<li><strong>Cabasse</strong> (e. Readly Express) – Salvatore Luongo</li>
</ol>



<p><strong>Försök II:</strong></p>



<ol class="wp-block-list">
<li><strong>Dimitri Ferm</strong> (e. Nad al Sheba) – Marco Stefani</li>



<li><strong>Ernesto Spritz</strong> (e. Maharajah) – Andrea Farolfi</li>



<li><strong>Joconde Sibey</strong> (e. Timoko) – Gabriele Gelormini</li>



<li><strong>Callisto </strong>(e. Nad al Sheba) – Gennaro Amitrano</li>



<li><strong>Freyr di Venere</strong> (e. Pascia’ Lest) – Alessandro Gocciadoro</li>



<li><strong>Cointreau</strong> (e. Nad al Sheba) – Antonio di Nardo</li>



<li><strong>Ziva</strong> (e. Varenne) – Björn Goop</li>



<li><strong>Cienfuegos Laumar </strong>(e. Ganymede) – Rene’ Legati</li>
</ol>



<p><strong>Försök III:</strong></p>



<ol class="wp-block-list">
<li><strong>Dolce Viky</strong> (e. Adrian Chip) – Antonio di Nardo</li>



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



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



<li><strong>Calima di Poggio </strong>(e. Crazed) – Italo Tamborrino</li>



<li><strong>Betting Pacer</strong> (e. Maharajah) – Björn Goop</li>



<li><strong>Demon di No</strong> (e. Nesta Effe) – Lucio Becchetti</li>



<li><strong>Eridano di Celle</strong> (e. Victor Gio) – Gennaro Riccio</li>



<li><strong>Dark Lady dei Rum</strong> (e. Looney Tunes) – Roberto Ruvolo</li>
</ol>



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



<p class="has-drop-cap">2<strong>Mantorptravet </strong>slog upp portarna 1965. Det året fanns en enda proffstränare vid banan: <strong>Sture Lindström</strong>. I eftermiddag (första start 13.45) hedras Sture med sitt eget lopp på banan som kördes första gången 2016, året innan Sture Lindström avled.<br>Sture Lindström var född och uppväxt i Skellefteå, där han inledde sin bana i travsporten.<br>I banprogrammet till eftermiddagens tävlingar berättas att hästägaren Åke Bengtsson i Linköping lockade Sture söderut när Mantorptravet skulle öppna och det blev drygt 40 år i Östergötland för Lindström. Som kusk plockade han sitt första banchampionat i Mantorp 1968 och totalt blev det nio titlar på hemmabanan, det sista togs 1981. Fler än någon annan på banan.</p>



<p><strong>Aspirant Nibs, Dictator Nibs, Parant Nibs, Red Nibs, Seabreeze, Ideal Way, Sweet Way</strong> och inkörsporten <strong>Hopp</strong> är hästar som förknippas med Sture Lindström.<br><em>”I Stures stall var det ordning och reda. Välorganiserat med fasta rutiner så långt det nu är möjligt i ett travstall”, </em>beskrivs Stures sätt att vara i Mantorps banprogram.</p>



<p>Sture Lindströms lopp bjuder 40.000 kronor i förstapris och innehåller flera spännande namn. Efter en sejour i Frankrike vann Markus B Svedberg-tränade <strong>Judge D.</strong> (e. Bird Parker) ett P21-lopp i återkomsten på svensk mark. Nu är tidigare rikstotovinnaren tillbaka i mer vanliga sammanhang. <br>Segervane <strong>Head of State</strong> (e. Muscle Hill) och Makethemarks lillebror <strong>Staro Royal Mark</strong> (e. Maharajah) är två tuffa utmanare att besegra.</p>



<p>Mantorp är enda svenska bana som tävlar och på Grand Slam 75-spelet är det jackpot med 2,6 miljoner kronor extra i de tre vinstpoolerna med procentfördelningen 40-20-40.</p>



<p><a href="https://sulkysport.se/wp-content/uploads/2025/11/23gs75.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till dagens tävlingar.</a></p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/svintenjop-617x362.jpg" alt="" class="wp-image-796183"/><figcaption class="wp-element-caption">Svinten och Jan-Olov Persson. Foto Stalltz.se</figcaption></figure>



<p class="has-drop-cap">3 Tidigare proffstränaren Per-Arne Abelin (Åmål) har gått ur tiden och han blev 64 år gammal. Lämnat jordelivet har också Herbert Lindqvist vid 94 års ålder.</p>



<p>Herbert Lindqvist födde upp två framgångsrika kallblod och i första hand storstjärnan <strong>Svinten</strong> (e. Svintor-Skarpa), 1.23,0ak/4.706.570 kr, som vann 103 lopp på 229 starter. En annan av hans duktiga uppfödningar var Svintens halvbror <strong>Karpen </strong>(e. Bestebrun), 1.24,6ak/922.455 kr.</p>



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



<p class="has-drop-cap">4 Franska travförbundet rapporterar månadsvis dopingprovtagningar och nu har resultatet kommit för oktober. </p>



<p>Totalt togs det 1.297 prover enligt följande:</p>



<ul class="wp-block-list">
<li>1.035 hästar provtogs efter lopp.</li>



<li>24 hästar provtogs vid ankomst till tävlingsbanan innan de deltog i ett lopp.</li>



<li>108 hästar togs prover i samband med kvalificeringslopp.</li>



<li>56 hästar togs prover under träningstester på 16 olika anläggningar.</li>



<li>13 prover togs som en del av det longitudinella övervakningsprogrammet.</li>



<li>Ett prov togs som en del av tester som utfördes på hästar som tillfälligt tagits ur träning.</li>
</ul>



<p>Av de 1.297 prover som togs – skriver franska travförbundet – upptäcktes fem förbjudna ämnen.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2021/07/romepaysoff-617x333.jpg" alt="" class="wp-image-186495"/><figcaption class="wp-element-caption">Rome Pays Off vid seger i försök till Sprintermästaren 2021. Foto Lars B Persson</figcaption></figure>



<p class="has-drop-cap">5Srf Stable-ägde jänkaren <strong>Rome Pays Off</strong> (e. Muscle Hill-Order By Wish), 1.09,7ak/6.338.691 kr, flyttar västerut igen, men inte ända till USA. Efter att ha tränats på europeisk mark av Robert Bergh, Daniel Wäjersten och senast konvalescenstränaren Caroline Holm, så är mångmiljonären ny i träning hos Frode Hamre.<br>– Jag fick frågan för ett par veckor sedan och var väldigt tacksam för det. Det är en häst med meriter och han är spännande. Vi behöver tävlingshästar i Norge i vinter, sade Frode Hamre till Rikstoto Direkte enligt Trav- og Galopp-Nytt.</p>



<p>Rome Pays Off slutade tvåa i såväl Breeders Crown som Peter Haughton Memorial under tvååringssäsongen medan han som treåring vann Tompkins-Geers ($89.100) och var finalist (galopp) i Hambletonian Stakes innan han plockades över till Sverige.<br>På svensk mark har Rome Pays Off vunnit Scandal Plays Minne och slutat tvåa i Konung Gustaf V:s Pokal och Sprintermästaren.</p>



<p>Rome Pays Off avelsvärderades förra hösten och tilldelades 75 poäng, högt skattat avelsvärde.</p>



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



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2025/11/headergrandstandnew2-617x231.jpg" alt="" class="wp-image-796078"/><figcaption class="wp-element-caption">Big Fresno Fair .</figcaption></figure>



<p class="has-drop-cap">6 Inga travlopp har körts i Kalifornien sedan Cal Expo slog igen portarna i början av maj i år. Nu har California Horse Racing Board givit klartecken för ett meeting på sex månader på Big Fresno Fair från 4 november 2026 till maj 2027.</p>



<p>Till skillnad mot Cal Expo blir det dagtävlingar eftersom Big Fresno Fair saknar belysning på travbanan.</p>



<p>– Publiken har inte spelat på sulkyhästarna på den här banan. Det är något som är okänt för spelarna och helt klart är det en chansning, säger Chris Schick, vd för Watch and Wager i ett pressmeddelande.</p>



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



<p class="has-drop-cap">7 I <strong>Reims</strong> (första start kl. 16.07) startar Jarmo Niskanen <strong>Katitzi </strong>(e. Earl Simon) i Prix du Manege (€21.000) och det femåriga stoet kommer närmast från en tredjeplats och innan dess stod hon med två raka triumfer. Nu handlar det om 2.500 meter autostart och i sulkyn sitter Joan Melis-Macias.</p>



<p>På samma bana och i Prix du Musee des Beaux-Arts (€25.000) sitter Marie Norberg upp bakom egentränade <strong>Justess Viking</strong> (e. Ubriaco) och även här är distansen 2.500 meter och startmetoden med bil.</p>



<p>Fredrik Wallin är också på plats med <strong>Libellue</strong> (e. Golden Bridge) i Prix du Palais du Tau (€18.000) och Anthony Barrier sitter upp i sulkyn bakom det fyraåriga stoet.</p>



<p><a href="https://www.letrot.com/courses/programme/2025-11-23/5102" data-type="link" data-id="https://www.letrot.com/courses/programme/2025-11-23/5102" target="_blank" rel="noreferrer noopener">Här hittar ni startlistorna till Reims tävlingar. </a></p>
