
<p class="has-drop-cap">1 Med finaler i Anders Kilströms Minne för tre- och fyraåringar med 100.000 kronor i förstapris spelar <strong>Bollnäs</strong> (första start 18.20) förstafiolen bland de tre svenska banor som tävlar idag. Det har blivit finaldags i hälsingebanans serie.</p>



<p>Långt innan Bollnästravet hade premiär i juli 1955 tävlade Anders Kilström med sina hästar på isen på den lilla sjön Vågen i centrala Bollnäs. Ikväll hedras Anders Kilström, som föddes 1894, med två minneslopp i form av finaler. Anders var pappa till travprofilerna Rune, Ivar och Börje där Ivar sedermera blev tränare på Solvalla. Idag lever familjens namn vidare på travbanorna via bland annat en viss Örjan Kihlström, son till Ivar och sonson till Anders Kilström.</p>



<p>Örjan finns dock inte på plats i Bollnäs där det istället kan handla mycket om Daniel Wäjersten. Han har finalister ”i varsin ände” i finalerna, där jänkarstoet <strong>Gigi Hanover</strong> (e. Chapter Seven) går ner i klass rejält bland fyraåringarna. Stoet, som bland annat var trea i Fyraåringseliten för ston, har sprungit in 2.531.895 kronor hittills i karriären. Hennes sex konkurrenter har tillsammans dragit ihop 1.428.700 kronor!</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/gigihanover-617x333.jpg" alt="" class="wp-image-653974"/><figcaption class="wp-element-caption">Gigi Hanover och Daniel Wäjersten. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Gigi Hanover inleder längst ut bakom bilen, medan Wäjerstens treåringshopp tjänat minst av de yngre finalisterna och har innerspår i debuten bakom startbilen. Hingsten var igång sent, men har imponerat i livets två starter i höst och vunnit båda.</p>



<p>Bollnäs bjuder också på ett kallblodslopp av god klass med hästar som <strong>Brageson</strong> (tre raka segrar), <strong>Höstbo Wille</strong> (vinnare av dubbelcupfinal i höst) och <strong>Guli Fantom</strong> (nybakad svensk montémästare) för att plocka ut tre travare i det meriterade fältet.</p>



<p>Bollnäs delar kvällens expresstrav med <strong>Örebro </strong>(start 18.30), där loppen är förbehållna hästar med högst 1.000 startpoäng. </p>



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



<p class="has-drop-cap">2 Tvåa och trea i Breeders Crown-försök i sommar och höst, men ingen start i semifinalerna på Solvalla på söndag. Istället väljer framgångsrika Umåkeramatören Anna Näslund att plocka ut sitt ämne <strong>General Silvio</strong> (e. Maharajah) i ett treåringslopp vid dagens lunchtävlingar i <strong>Boden</strong> (första start 12.20).</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/10/generalsilvio-617x333.jpg" alt="" class="wp-image-653973"/><figcaption class="wp-element-caption">Anna Näslund-tränade General Silvio och Tomas Pettersson. Foto Mathias Hedlund/Sulkysport</figcaption></figure>



<p>Anna Näslund köpte hästen från uppfödaren och ägaren Stall Silvio i somras. Då hade General Silvio gjort nio starter och tagit tre pallplaceringar. Hos Näslund har han hunnit med fem starter (1-1-1) och bland annat varit tvåa bakom trippelmiljonären <strong>Phantom Express</strong> och trea bakom Kriterievinnaren <strong>Bullet the Bluesky</strong> i två BC-försök. I Kriteriekvalet i senaste starten var det dock tomt i tanken in i slutsvängen.</p>



<p>40 meters tillägg och hemmakusken Sandra Eriksson i vagnen för första gången är dagens uppgift, där åtta hästar startar 40 respektive 20 meter före.</p>



<p>Sandra plockar å sin sida ut egentränade <strong>Swagger </strong>(e. Zola Boko) i ett flerklasslopp, också från 40 meters tillägg, men med 14 konkurrenter framför. Bland dessa finns segermaskinen <strong>Jamie Sisu</strong> (e. Nuncio), 13 vinster på 22 starter, Kriteriefemma från 2021 <strong>Henessi Walk</strong> (e. Walk the Walk) och forne Big Noon-pokalen-segraren <strong>Daven Port </strong>(e. Cantab Hall). </p>



<p><a href="https://sulkysport.se/wp-content/uploads/2024/10/241101.pdf" data-type="link" data-id="https://sulkysport.se/wp-content/uploads/2024/10/241101.pdf" target="_blank" rel="noreferrer noopener">Här är startlistorna till fredagens tävlingar. </a></p>



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



<p class="has-drop-cap">3 Gran Premio Paolo e Orsino Orsi Mangelli (€300.300) avgörs i Turin idag och störst intresse drar Europas snabbaste treåring till sig. I Turin dyker franskfödde <strong>Lovino Bello</strong> (e. Village Mystic), 1.09,7ak*/€420.895, upp och körs av Eric Raffin.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2024/07/cravoisier2-617x409.jpg" alt="" class="wp-image-611861"/><figcaption class="wp-element-caption">Lovino Bello kaunde titulera sig Europas snabbaste treåring genom tiderna efter ha vunnit på 1.09,7a/1.609 meter på Enghien i somras. Foto: Gerard Forni</figcaption></figure>



<p>Det tävlas i två försök och de fem främsta går vidare till finalen som avgörs samma dag.</p>



<p><strong>Gran Premio Orsi Mangelli</strong> (€22.000) – försök I:<br>Treåringar.<br><em>1.600 meter, autostart.</em></p>



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



<ol class="wp-block-list">
<li><strong>Lovino Bello</strong> (e. Village Mystic – Eric Raffin</li>



<li><em>Far West Bi<strong> </strong>– struken</em></li>



<li><strong>First of Mind</strong> (e. Face Time Bourbon) – Roberto Vecchione</li>



<li><strong>Frankie LJ </strong>(e. Readly Express) – Alessandro Gocciadoro</li>



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



<li><strong>Felipe Roc</strong> (e. Filipp Roc) – Santo Mollo</li>



<li><strong>Flash NP </strong>(e. Owen Cr) – Ferdinando Pisacane</li>



<li><strong>Fly Top </strong>(e. Tesoro Degli Dei) – Antonio Simioli</li>
</ol>



<h2 class="wp-block-heading">Försök II:</h2>



<ol class="wp-block-list">
<li><strong>Feldenkrais Pal</strong> (e. Trixton) – Robin Bakker</li>



<li><strong>Fortunadrago Font </strong>(e. Quite Easy) – Enrico Bellei</li>



<li><strong>Fargo Wise As</strong> (e. Walner) – Vincenzo Luongo</li>



<li><strong>Fantastica Doda</strong> (e. Maharajah) – Santo Mollo</li>



<li><strong>Ferahan As</strong> (e. Maharajah) – Mario Minopolo Jr.</li>



<li><strong>Falco Killer Gar </strong>(e. Varenne) – Alessandro Gocciadoro</li>



<li><strong>Little Brown </strong>(e. Goetmals Wood) – Gabriele Gelormini</li>



<li><strong>Frankie Bar </strong>(e. Oropuro Bar) – Marco Stefani</li>



<li><strong>Floy di Girifalco </strong>(e. Donato Hanover) –Gennaro Ricchio</li>
</ol>



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



<p class="has-drop-cap">4 Och det bjuds enligt traditionen också på en stoavdelning i Orsi Mangelli (€88.000) över distansen 1.600 meter. Alessandro Gocciadoros<strong> Funny Gio</strong> (e. Face Time Bourbon), 1.12,1ak*/€242.566, har ett starkt år bakom sig med segrar i GP-löpningarna Etruria, Italia, Campionato Femminimile 3 anni och Carlo Marangoni Filly, men har lottats till spår åtta. </p>



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/10/skarmavbild20241031kl.10.54.30.png" alt="" class="wp-image-654295"/></figure>



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



<p class="has-drop-cap">5 <strong>Volstead </strong>gör stor succé som avelshingst i Australien och hans treåringar passerade en miljon australienska dollar i helgen. Ingen annan avelshingst har varit i närheten av sådana summor tidigare och den tidigare rekordinnehavaren <strong>Majestic Son</strong> fick ihop 771.218 dollar som bäst under en och samma säsong.</p>



<figure class="wp-block-image size-sulky-mellan2"><img src="https://sulkysport.se/wp-content/uploads/2018/08/volsteadml2-617x288.jpg" alt="" class="wp-image-28825"/><figcaption class="wp-element-caption">Volstead. Foto: Jeanie Karlsson/Sulkysport</figcaption></figure>



<p>Per den 31 oktober har Volsteads treåringar dragit in 1.000.970 dollar, medan Majestic Son är tvåa med 264.584 dollar och Love You trea med 188.585 dollar. </p>



<p>Av Volsteads 35 startande avkommor har 21 vunnit lopp. Stoet <strong>Keayang Zahara </strong>är obesegrad i elva starter och kullbrodern <strong>Derek the Jet</strong> är inte mycket sämre utan ha inlettt sin karriär med tio vinster på lika många framträdanden.</p>



<p>Vinstrikast av hans treåringar är <strong>Keayang Zahara</strong> ($267.330), <strong>Derek the Jet </strong>($198.890), <strong>Maori’s Mac</strong> ($145.805), <strong>Violet Stanford</strong> ($126.730) och <strong>Nordic Reign </strong>($91.101).</p>



<p>Noteras kan också att Volstead är ledande avelshingst bland tvååringarna också med 230.183 dollar, följd av Father Patrick med 155.000 dollar.</p>



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



<figure class="wp-block-image size-full"><img src="https://sulkysport.se/wp-content/uploads/2024/10/dunndexter240726adamstromstalltz-scaled.jpg" alt="" class="wp-image-652462"/><figcaption class="wp-element-caption">Dexter Dunn. Foto: Adam Ström/stalltz.se</figcaption></figure>



<p class="has-drop-cap">6 När Ron Pierce vann sin första Breeders Crown-titel med <strong>Giant Victory </strong>1991 var han 35 år och 125 dagar, David Miller var 35 år och 268 dagar när han räknade in sin första BC-final med <strong>Magician</strong> 2000, medan Brian Sears var 35 år och 306 dagar när <strong>Stroke Pla</strong>y vann 2003. Inga dunungar precis…</p>



<p>Dexter Dunn är också 35 år (och 57 dagar) och han har redan 21 finalvinster i Breeders Crown, varav sex segrar togs i förra veckoslutet.</p>



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



<p class="has-drop-cap">7 Inga tävlingar på<strong> Vincennes</strong> idag, men däremot hålls en högt doterad löpning i <strong>Laval </strong>(kl. 15.15) för äldre travare. Det handlar om Grand Prix de la Ville de Laval (€70.000) för europeiska travare mellan fem och tio år. Där startar Erik Bondo svenskfödde <strong>Bordeaux S </strong>(e. Orlando Vici) och han står med 25 meters tillägg över grunddistansen 2.850 meter. Jean-Philippe Monclin sitter i sulkyn.</p>



<p>Till<strong> Le Croise-Laroché</strong> (första start kl. 16.07) åker Björn Goop-tränade <strong>Javlar</strong> (e. Charly du Noyer) och startar i Prix du Golf des Flanders (€21.000) för femåriga hingstar/valacker över medeldistans med autostart. Jérémy Koubiche har kontrakterats till styrningen.</p>



<p>Jarmo Niskanen finns också på plats med treårige <strong>Lanselod Lenn </strong>(e. Earl Simon) och Joan Melis Macias sitter upp bakom valacken i Prix de l’Olympique Rugny Marcquois (€18.000) över 2.700 meter med autostart. Lanselod Lenn jagar sin andra seger i karriären efter ha tagit sin första seger i Dieppe den 18 september på gräs.</p>
