
<p class="has-drop-cap wp-block-paragraph">Jägersro står som värd för omgången när V75 firar 30 år. Det är en riktigt trevlig utmaning som spelarna ställs inför under jubileumsomgången och vi har verkligen tänt till på den utmaning som medföljer då de där givna singelstrecken lyser med sin frånvaro.</p>



<p class="wp-block-paragraph"><strong>Admiral As</strong> (V75-3) blir säkert omgångens största favorit när spelet väl har satt sig ordentligt. Visst har han god chans att spåra hela vägen om han får överta ledningen relativt smärtfritt, men vi betalar även för <strong>Power</strong> och <strong>Hierro Boko</strong> på vårt system då det inte är någon garanti att favoriten vinkas fram.</p>



<p class="wp-block-paragraph">Roligaste spiken är istället <strong>Ninja Zon </strong>(V75-5) som såg helt ljuvlig ut i debuten för André Eklundh. Stoet har tre V75-segrar på sitt cv sedan tidigare och känns superspännande från ett perfekt utgångsläge i en spårtrappa där vi inte tycker att de mer rutinerade hästarna nödvändigtvis ska vara bättre än henne.</p>



<p class="wp-block-paragraph"><a href="https://sulkysport.se/wp-content/uploads/2023/10/28v75.pdf" target="_blank" rel="noreferrer noopener">Här kan du ta del av startlistor till tävlingarna på Jägersro.</a></p>



<p class="wp-block-paragraph"><em>Vill du spela V75 tillsammans med Sulkysport finns följande alternativ:</em></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206687_V75_2023-10-28_7_5" target="_blank" rel="noreferrer noopener">Sulkysport Lilla V75 – 15 andelar á 75 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206688_V75_2023-10-28_7_5" target="_blank" rel="noreferrer noopener">Sulkysport V75 – 15 andelar á 150 kr/styck</a></p>



<p class="wp-block-paragraph"><a href="https://www.atg.se/andelskungen/spel/206689_V75_2023-10-28_7_5" target="_blank" rel="noreferrer noopener">Sulkysport Stora V75 – 15 andelar á 250 kr/styck</a></p>



<h2 class="wp-block-heading">Avd 1 – Bronsdivisionen, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Midnight Special </strong>vann en final i Summer Meetings i somras och har fortsatt leverera starka insatser efter det även om utdelningen inte varit densamma. Han har bytt regi efter senaste starten och finns numera hos Adrian Kolgjini som lyckats ytterst väl med hästar som anslutit från Helena Burmans stall. Midnight Special har tagit små, successiva steg in i Bronsdivisionen och lär säkert komma väl förberedd inför denna start när det handlar om hemmaplan och regidebut.</li>



<li><strong>In Love Mearas</strong> fick jaga från fjärde utvändigt i Klass I-finalen på Solvalla. Körande Mats E Djuse chansade invändigt i slutkurvan, men kom aldrig loss med femåringen utan blev fast med sparade krafter. In Love Mearas har bättrat sig lite för varje lopp han fått i nuvarande regi även om han inte radat upp segrar. Oavsett om han lyckas vinna starten eller få ett lopp i draget ska han hävda sig väl här.</li>



<li><strong>Lucifer Boko</strong> hakade på starkt i en tuff Bronsdivisionsfinal senast på Solvalla och gick i mål med lite sparade krafter via en tripp i tredje invändigt. Hästen är extremt jämn, gör nästan aldrig en dålig insats och står smaskigt placerad i det här loppet för att antingen vinna starten eller få ett lopp i vinnarhålet.</li>



<li><strong>Eddie the Eagle</strong> spårade hem ett Bronsdivisionsförsök på Axevalla den 22 juli över gällande distans. Då inledde han från spår tre vilket givetvis är en markant skillnad kontra att som nu sprinta igång från spår sju.</li>



<li><strong>Enjoy Banker</strong> blev utsvarad vid häftig attack i tredjespår ut på sista bortre långsidan senast på Lunden och galopperade av iver när 300 meter återstod. Han är normalt sett säker på benen och även om han inte lyckas vinna starten så kommer han kunna sitta bra till längs sargen.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>4-2-3-7<strong> B: </strong>1-6-11-12-9-10 <strong>C: </strong>5-8</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Lömsk inledning med många raska. <strong>Lucifer Boko</strong> tror vi kan jobba sig förbi<strong> Enjoy Banker </strong>som kan få svårt att accelerera maximalt från innerspår, men vi håller <strong>Midnight Special </strong>som snabbast av alla. <strong>Eddie the Eagle</strong> är också rask från början, men får svårt att ta sig förbi samtliga från spår sju.</p>



<h2 class="wp-block-heading">Avd 2 – Klass II, 2.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Countess Face </strong>har överkapacitet för det här sällskapet och vi hade tveklöst kunnat se henne ta en topplacering i Svenskt TravOaks om det inte vore för att hon plötsligt började bromsa i ledningen i kvallloppet och fick tas ur fältet. Det beteende gjorde att hon tilldömdes ett nytt kvallopp i vilket hon kördes i rygg och avslutade 1.08 sista 400 meterna i bländande stil. Countess Face är så pass bra att vi – lite hårddraget – ser henne som favorit till segern även om hon skulle sitta sist i fältet halvvarvet före mål och tempot varit lågt.</li>



<li><strong>True Blue</strong> har inlett sin sejour på svensk mark med tre raka segrar och ser inte ut att vara någon bluff. Hon trampade iväg från ett snävt startspår senast på Jägersro och fick bitvis vandra utvändigt ledaren, men antog den utmaningen med besked. Tar hon sig ner mot en låg 1.14-tid eller går aningen snabbare här så ger hon Countess Face en match.</li>



<li><strong>De Chambeau </strong>fick gnugga dödens på Let Me In i Breeders Course bonuslopp senast på Jägersro, men gav densamme en match hela vägen in till mållinjen. Stängt bakspår nu är inte optimalt, men med klaff på bitarna duger han väl.</li>



<li><strong>Tug of War </strong>slutade tvåa bakom Barack Face i debuten på svensk mark ifjol, men har blandat och gett en hel del efter det. Nu börjar han bli jämnare i sina prestationer och det faktum att han är anmäld barfota runt om för första gången kittlar.</li>



<li><strong>Alessio</strong> gjorde två misslyckade STL-starter i våras, men laddar nu om i det sammanhanget efter ett plusbetonat genrep.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>6 <strong>B:</strong> 4-8-9-2-12-7-1-5 <strong>C: </strong>11-10</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Countess Face </strong>har en rimlig chans att ta sig förbi <strong>Moira Boko </strong>direkt, men utifrån hur hon uppträdde på Solvalla i Oakskvalet så lär Adrian Kolgjini vilja ha rygg. Får<strong> True Blue</strong> överta?</p>



<h2 class="wp-block-heading">Avd 3 – C.L. Müllers Memorial, 2.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Admiral As</strong> ställdes inför en omöjlig uppgift i UET Circle Finale på Solvalla då han fick jaga från femte utvändigt samtidigt som Hohneck avslutade slutvarvet pilsnabbt. Ready Cash-sonen gjorde vad han kunde och att han fick släppa bakomvarande San Moteur förbi sig med en längd var inget att säga något om då vi tycker att det är en bättre häst. Admiral As har varit superbra vid de tidigare starterna och då vi tror att han kan forceras till tät i det här loppet kan det vara löpningsavgörande.</li>



<li><strong>Power</strong> drog nitlotten i UET Circle Finale då han fick kajka i dödens. Det blev fullt naturligt för tufft för hans del och vi säger ingenting om att han fick trötta ben till slut. Vid segern i Svenskt Mästerskap tangerade han världsrekordet efter att forcerats till tät, men hästen går även bra bakifrån så det är inte så att Power står utan chans på grund av spår nio.</li>



<li><strong>Hierro Boko</strong> trodde vi hade gått helt ur form av höstens inledande starter att döma, men han gick en jätteupphämtning efter galopp i UET Circle Finale och visade att formen visst kvarstår. Nioåringen var trea vid sitt senaste besök på Jägersro i Hugo Åbergs Memorial och tillhör motbuden till Admiral As.</li>



<li><strong>Ultion Face</strong> gick en stark långspurt senast bakom Dats So Cool och ska vara allt mer uppåt nu med tre lopp i kroppen. Den här uppgiften är dock kämpig från spår elva.</li>



<li><strong>Unico Broline</strong> har det inte slagit gnistor om i år, men han såg ut att gå i mål med en del sparade krafter senast på Axevalla. Det blir intressant att se om täta starter kan föra honom framåt.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>5 <strong>B: </strong>9-3-11-2-8-4 <strong>C: </strong>12-1-6</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Även om <strong>Unico Broline</strong> säkert kan hålla ledningen om man så önskar så tror vi att man lämnar över taktpinnen till <strong>Admiral As</strong>.</p>



<h2 class="wp-block-heading">Avd 4 – Klass I, 1.640 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Need&#8217;em </strong>blir vårt tipsval i ett vidöppet Klass I-försök där det känns som att det mesta kan hända. Han fick chansen för sent från tredje invändigt senast på Romme för att kunna hinna ikapp ledarinnan Dana Ek som vi håller som ett riktigt bra sto, men avslutningen till andraplatsen var det sannerligen inget fel på. Need&#8217;em hade inte startat på närmare två månader före det loppet och det är rimligt att tro att han går framåt med loppet i kroppen. Droppar Örjan Kihlström ner i en hygglig position med Need&#8217;em kan han bli svår att stå emot i ett förmodat överpacat lopp.</li>



<li><strong>Kyrie Eleison</strong> drog fram <strong>Game On Butcher</strong> senast på Åby och höll klart bra till tredjeplatsen. Han var bara slagen med en längd av den nämnde vinnaren och vi tycker det är ett klart plus att Björn Goop fått lära sig hästen en period och vet allt bättre vilka knappar han ska trycka på. Det här är en häst som vi kan se ta flera steg upp på STL-trappan och då duger han givetvis bra här.</li>



<li>Game On Butcher blev fint framdragen bakom Kyrie Eleison i det nämnda Åbyloppet och avgjorde med en längd som marginal. Han har vunnit sex av åtta starter på svensk mark och även om ytterligare ett halvvarv kanske hade varit att föredra så kan han komma in i matchen här på styrka då loppet har förutsättningar för att bli överpacat.</li>



<li><strong>Warrior&#8217;s Tale </strong>gick sig trött i ledningen senast efter att öppnat i alldeles för häftig fart. Skulle han få ett bra lopp i draget nu istället tar han många till slut.</li>



<li><strong>Breidabliks Bombay</strong> har en andra- och en tredjeplats som bästa STL-resultat efter fyra försök. Nu aviseras det skoryck samt jänkarvagn och från tät kan vi se honom rusa iväg så pass att de andra helt enkelt inte får tag på honom.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>8-6-9 <strong>B:</strong> 2-4-11-7-3-10 <strong>C: </strong>1-5-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Här kan det gå undan! <strong>Warrior&#8217;s Tale </strong>lägger iväg bra, men när det aviseras helstängt huvudlag på <strong>Breidabliks Bombay</strong> så undrar vi om han verkligen går att ta emot. Utifrån lär <strong>Kyrie Eleison</strong> och <strong>Darwih Wise L.</strong> testas för position även om de har spår långt ut bakom vingen.</p>



<h2 class="wp-block-heading">Avd 5 – Diamantstoet, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>Ninja Zon</strong> har tre V75-segrar på sitt cv i tidigare regi så det är verkligen ingen nyhet att den här hästen kan springa. Däremot så tycker vi att intrycket i debuten för André Eklundh var ytterligare en nivå till upp på skalan då hon brakade runt sina motståndare via 1.10 sista varvet från sjunde utvändigt. Ninja Zon såg verkligen morsk ut och tog striden trots det tuffa lopp som blev på ett övertygande vis och står än bättre placerad i det här loppet. Det mesta tyder på att hon kommer få en resa långt fram i fältet och även om det inte blir ledningen så känns hon klart spelvärd som spik till enkelprocent.</li>



<li><strong>Carroty</strong> har lyft flera snäpp med jänkarvagn. Hon mötte ett liknande gäng näst senast på Åby och fick en småtuff inledning, men stod pall för det. Den här gången är stoet anmäld barfota runt om vilket kan bli ytterligare en kick om man fullföljer och kör med den balansen även i avgörandets stund.</li>



<li><strong>Lady Beluga </strong>har inte tävlat på lördagar i år, men likväl startat i tuffa sällskap och kurvan har varit uppåt hela tiden. Hon står sämst till i den här spårtrappan, men ingen går säker för henne om hon får lite draghjälp.</li>



<li><strong>Nova Mahiron</strong> går ner i klass efter att startat i Sto-SM i senaste starten. Hon har dubbla segrar i Stoeliten på sitt cv under året, men då har hon till skillnad mot detta lopp stått med öppet startspår.</li>



<li><strong>Olga Utca </strong>slog det inte gnistor om i lördags, men nu är hon anmäld såväl barfota fram som med jänkarvagn och det är stora plusfaktorer.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>2<strong> B: </strong>1-11-10-9-7-4-3<strong> C:</strong> 8-5-6</p>



<p class="wp-block-paragraph"><strong>Spetsstriden:</strong> <strong>Carroty</strong> är rask iväg, men det är inte enkelt att fronta från innerspår. <strong>Ninja Zon </strong>har chans att komma förbi, men vi tycker att hon är väl så bra om inte bättre bakifrån.</p>



<h2 class="wp-block-heading">Avd 6 – Oktoberstayern, 3.140 meter voltstart</h2>



<ul class="wp-block-list">
<li><strong>Bottnas Idol </strong>fick dra tåget i tredjespår senast på Jägersro och höll helt okej som trea. Han var inte riktigt mogen en &#8221;knallprestation&#8221; när han bara hade ett lopp i kroppen, men lär gå framåt rejält med de två ögonöppnarna. Förutsättningarna med tävling över tre varv passar honom som hand i handske och vi väljer att tippa femåringen först.</li>



<li><strong>Hashtag Simoni </strong>har utvecklats markant det sista kvartalet och det var inget att säga något om att han &#8221;bara&#8221; blev trea senast på Solvalla. Hästen fick anfalla i vida spår i slutkurvan från djup köposition och fick helt sonika för långt fram. När Vision of Gideon är struken på startvolten så ska chansen att Hashtag Simoni kan forceras till tät vara god.</li>



<li><strong>Amazing Justice </strong>vann K.G.Bertmarks Minne i början av september och vi påminner om att hästen därtill slutade tvåa i Norskt Travderby under fjolåret. Hästens högstanivå är tveklöst tillräckligt hög för att han ska kunna göra sig gällande här och han är vår stora varning i detta lopp.</li>



<li><strong>Even Steven</strong> satt två hack längre bak än Bottnas Idol senast på Jägersro och drog nytta av att få hans draghjälp. Insatsen var god, men då vi tror att tidigare nämnda konkurrent kommit längre formmässigt nu med två lopp i kroppen så kan ordningsföljd de två emellan bli annorlunda.</li>



<li><strong>Eagle Rock </strong>fick traska i dödens senast på Åby och gick sig trött. Han kan gå framåt med lopp i kroppen, men vi är aningen tveksamma till om han verkligen står rätt inne i det här stayerloppet på mellanvolten.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>9-5-14-13 <strong>B: </strong>6-4-1-12-11-3 <strong>C: </strong>10-8-7-15</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: </strong>Vi blir väldigt förvånade om spetsfavoriten<strong> Staro Quantas</strong> körs i ledningen över tre varv och tror att taktpinnen lämnas över till <strong>Hashtag Simoni </strong>i tidigt skede.</p>



<h2 class="wp-block-heading">Avd 7 – Silverdivisionen, 2.140 meter autostart</h2>



<ul class="wp-block-list">
<li><strong>King of Everything </strong>fick öppna 1.07,5 första halvvarvet och 1.10,5 första varvet senast i Kalmar vilket helt enkelt blev honom övermäktigt. Vi tycker ändå att han höll helt okej och det är ett stort plus att det blir jänkarvagn denna gång istället för vanlig vagn. Från ett utsökt utgångsläge är han klar spetsfavorit och från den positionen blir han inte enkel att passera.</li>



<li><strong>Glamorous Rain </strong>satt fast med rubbet sparat i vinnarhålet senast i Stoeliten. Hon kom bort helt från svårt startspår gången innan i Sto-SM och det loppet kan man bara dra ett streck över. Tvåan från European Championship for Mares har propositionsmässig fördel i den här Silverdivisionen och kommer bli svår att stå emot i slutskedet.</li>



<li><strong>Boli You S.M. </strong>fullföljde bra efter sen lucka från vinnarhålet i Bronsdivisionens final på Solvalla. Han steppar upp en klass nu, men den här hästen har tagit stora steg i sin utveckling heal tiden och vi finner ingen anledning att tro att det ska behöva börja ta emot i det här skedet.</li>



<li><strong>Rossi Garline </strong>har tagit tre raka segrar varav den senaste bärgades från dödens över opassande kort distans. Han gynnas av att tävla över ytterligare ett halvvarv  och går inte räkna bort i nuvarande slag.</li>



<li><strong>Ture L.A.</strong> galopperade i en stökig situation in mot första kurvan senast i Silverdivisionens final. Han stod för en bra upphämtning i skymundan och har varit fin vid spetssegrarna dessförinnan. Även om det blir svårt att komma förbi King of Everything så tror vi att Johan Untersteiner kommer göra ett ordentligt försök i jakt på så bra position som möjligt.</li>
</ul>



<p class="wp-block-paragraph"><strong>Rank:</strong></p>



<p class="wp-block-paragraph"><strong>A: </strong>2-10 <strong>B: </strong>9-5-7-11-4-1-3 <strong>C:</strong> 6-12</p>



<p class="wp-block-paragraph"><strong>Spetsstriden: King of Everything</strong> ska inte ha några problem att hålla ut raske <strong>Ture L.A.</strong> initialt.</p>



<p class="wp-block-paragraph">	
				<div class="factbox full ">
			<div class="insidefactbox">
				<div class="overflow">
					<div class="height">
						<div class="padding">
							<div class="factvinjett">Fakta</div>
							
															<h3 class="title">
									V75-FÖRSLAGET 28 OKTOBER								</h3>
														<div class="content">
								
<p class="wp-block-paragraph"><strong>Avd 1: </strong>1,2,3,4,6,7,11,12 (9,10)<br><strong>Avd 2: </strong>6 Countess Face (4,8)<br><strong>Avd 3: </strong>3,5,9 (11,2)<br><strong>Avd 4: </strong>2,3,4,6,7,8,9,10,11 (1,5)<br><strong>Avd 5: </strong>2 Ninja Zon (1,11)<br><strong>Avd 6: </strong>4,5,6,9,13,14 (1,12)<br><strong>Avd 7:</strong> 2,9,10 (5,7)</p>



<p class="wp-block-paragraph"><em>3.888 rader / 1.944 kronor</em></p>
							</div>
						</div>
					</div>
				</div>
							</div>
		</div>
	
	</p>
